YES(O(1),O(n^4)) We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict Trs: { +(@x, @y) -> #add(@x, @y) , and(@x, @y) -> #and(@x, @y) , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() } Weak Trs: { #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We add following dependency tuples: Strict DPs: { +^#(@x, @y) -> c_1(#add^#(@x, @y)) , and^#(@x, @y) -> c_2(#and^#(@x, @y)) , append^#(@l, @ys) -> c_3(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_4(append#2^#(append(@xs, @ys), @x), append^#(@xs, @ys)) , append#1^#(nil(), @ys) -> c_5() , append#2^#(@l', @x) -> c_6() , bitonicMerge^#(@l, @direction) -> c_7(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_8(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#1^#(nil(), @direction, @l) -> c_9() , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#2^#(nil(), @direction, @l) -> c_11() , bitonicMerge#3^#(@h, @direction, @l) -> c_16(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_15(div2#1^#(@n)) , length^#(@l) -> c_14(length#1^#(@l)) , bitonicMerge#10^#(#false(), @hi, @low) -> c_12() , bitonicMerge#10^#(#true(), @hi, @low) -> c_13() , length#1^#(::(@x, @xs)) -> c_37(+^#(#pos(#s(#0())), length(@xs)), length^#(@xs)) , length#1^#(nil()) -> c_38() , div2#1^#(#0()) -> c_33() , div2#1^#(#s(@n)) -> c_34(div2#2^#(@n)) , bitonicMerge#4^#(@s, @direction) -> c_18(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_17(splitAt#1^#(@n, @l)) , splitAt#1^#(#0(), @l) -> c_45() , splitAt#1^#(#s(@n'), @l) -> c_46(splitAt#2^#(@l, @n')) , bitonicMerge#5^#(@hi, @direction, @s) -> c_20(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_19(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_23(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_22(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction), bitonicMerge#10^#(@direction, @hi, @low)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_21(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_25(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_24(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_54(zipWithOr#2^#(@l2, @x, @xs)) , zipWithOr#1^#(nil(), @l2) -> c_55() , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_50(zipWithAnd#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(nil(), @l2) -> c_51() , bitonicSort^#(@l, @dir) -> c_26(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_27(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#1^#(nil(), @dir, @l) -> c_28() , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_30(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , split^#(@l) -> c_29(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_40(split#2^#(@xs, @x1)) , split#1^#(nil()) -> c_41() , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_31(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_32(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , div2#2^#(#0()) -> c_35() , div2#2^#(#s(@n)) -> c_36(+^#(#pos(#s(#0())), div2(@n)), div2^#(@n)) , or^#(@x, @y) -> c_39(#or^#(@x, @y)) , split#2^#(::(@x2, @xs'), @x1) -> c_42(split#3^#(split(@xs'), @x1, @x2), split^#(@xs')) , split#2^#(nil(), @x1) -> c_43() , split#3^#(tuple#2(@l1, @l2), @x1, @x2) -> c_44() , splitAt#2^#(::(@x, @xs), @n') -> c_47(splitAt#3^#(splitAt(@n', @xs), @x), splitAt^#(@n', @xs)) , splitAt#2^#(nil(), @n') -> c_48() , splitAt#3^#(tuple#2(@l1, @l2), @x) -> c_49() , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_52(and^#(@x, @y), zipWithAnd^#(@xs, @ys)) , zipWithAnd#2^#(nil(), @x, @xs) -> c_53() , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_56(or^#(@x, @y), zipWithOr^#(@xs, @ys)) , zipWithOr#2^#(nil(), @x, @xs) -> c_57() } Weak DPs: { #add^#(#0(), @y) -> c_58() , #add^#(#pos(#s(#0())), @y) -> c_59(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_60(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #and^#(#false(), #false()) -> c_63() , #and^#(#false(), #true()) -> c_64() , #and^#(#true(), #false()) -> c_65() , #and^#(#true(), #true()) -> c_66() , #or^#(#false(), #false()) -> c_67() , #or^#(#false(), #true()) -> c_68() , #or^#(#true(), #false()) -> c_69() , #or^#(#true(), #true()) -> c_70() , #succ^#(#0()) -> c_75() , #succ^#(#pos(#s(@x))) -> c_76() , #succ^#(#neg(#s(#0()))) -> c_77() , #succ^#(#neg(#s(#s(@x)))) -> c_78() , #pred^#(#0()) -> c_71() , #pred^#(#pos(#s(#0()))) -> c_72() , #pred^#(#pos(#s(#s(@x)))) -> c_73() , #pred^#(#neg(#s(@x))) -> c_74() } and mark the set of starting terms. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { +^#(@x, @y) -> c_1(#add^#(@x, @y)) , and^#(@x, @y) -> c_2(#and^#(@x, @y)) , append^#(@l, @ys) -> c_3(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_4(append#2^#(append(@xs, @ys), @x), append^#(@xs, @ys)) , append#1^#(nil(), @ys) -> c_5() , append#2^#(@l', @x) -> c_6() , bitonicMerge^#(@l, @direction) -> c_7(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_8(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#1^#(nil(), @direction, @l) -> c_9() , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#2^#(nil(), @direction, @l) -> c_11() , bitonicMerge#3^#(@h, @direction, @l) -> c_16(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_15(div2#1^#(@n)) , length^#(@l) -> c_14(length#1^#(@l)) , bitonicMerge#10^#(#false(), @hi, @low) -> c_12() , bitonicMerge#10^#(#true(), @hi, @low) -> c_13() , length#1^#(::(@x, @xs)) -> c_37(+^#(#pos(#s(#0())), length(@xs)), length^#(@xs)) , length#1^#(nil()) -> c_38() , div2#1^#(#0()) -> c_33() , div2#1^#(#s(@n)) -> c_34(div2#2^#(@n)) , bitonicMerge#4^#(@s, @direction) -> c_18(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_17(splitAt#1^#(@n, @l)) , splitAt#1^#(#0(), @l) -> c_45() , splitAt#1^#(#s(@n'), @l) -> c_46(splitAt#2^#(@l, @n')) , bitonicMerge#5^#(@hi, @direction, @s) -> c_20(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_19(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_23(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_22(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction), bitonicMerge#10^#(@direction, @hi, @low)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_21(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_25(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_24(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_54(zipWithOr#2^#(@l2, @x, @xs)) , zipWithOr#1^#(nil(), @l2) -> c_55() , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_50(zipWithAnd#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(nil(), @l2) -> c_51() , bitonicSort^#(@l, @dir) -> c_26(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_27(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#1^#(nil(), @dir, @l) -> c_28() , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_30(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , split^#(@l) -> c_29(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_40(split#2^#(@xs, @x1)) , split#1^#(nil()) -> c_41() , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_31(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_32(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , div2#2^#(#0()) -> c_35() , div2#2^#(#s(@n)) -> c_36(+^#(#pos(#s(#0())), div2(@n)), div2^#(@n)) , or^#(@x, @y) -> c_39(#or^#(@x, @y)) , split#2^#(::(@x2, @xs'), @x1) -> c_42(split#3^#(split(@xs'), @x1, @x2), split^#(@xs')) , split#2^#(nil(), @x1) -> c_43() , split#3^#(tuple#2(@l1, @l2), @x1, @x2) -> c_44() , splitAt#2^#(::(@x, @xs), @n') -> c_47(splitAt#3^#(splitAt(@n', @xs), @x), splitAt^#(@n', @xs)) , splitAt#2^#(nil(), @n') -> c_48() , splitAt#3^#(tuple#2(@l1, @l2), @x) -> c_49() , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_52(and^#(@x, @y), zipWithAnd^#(@xs, @ys)) , zipWithAnd#2^#(nil(), @x, @xs) -> c_53() , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_56(or^#(@x, @y), zipWithOr^#(@xs, @ys)) , zipWithOr#2^#(nil(), @x, @xs) -> c_57() } Weak DPs: { #add^#(#0(), @y) -> c_58() , #add^#(#pos(#s(#0())), @y) -> c_59(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_60(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #and^#(#false(), #false()) -> c_63() , #and^#(#false(), #true()) -> c_64() , #and^#(#true(), #false()) -> c_65() , #and^#(#true(), #true()) -> c_66() , #or^#(#false(), #false()) -> c_67() , #or^#(#false(), #true()) -> c_68() , #or^#(#true(), #false()) -> c_69() , #or^#(#true(), #true()) -> c_70() , #succ^#(#0()) -> c_75() , #succ^#(#pos(#s(@x))) -> c_76() , #succ^#(#neg(#s(#0()))) -> c_77() , #succ^#(#neg(#s(#s(@x)))) -> c_78() , #pred^#(#0()) -> c_71() , #pred^#(#pos(#s(#0()))) -> c_72() , #pred^#(#pos(#s(#s(@x)))) -> c_73() , #pred^#(#neg(#s(@x))) -> c_74() } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We estimate the number of application of {1,2,5,6,9,11,15,16,18,19,23,33,35,38,42,45,47,49,50,52,53,55,57} by applications of Pre({1,2,5,6,9,11,15,16,18,19,23,33,35,38,42,45,47,49,50,52,53,55,57}) = {3,4,7,8,13,14,17,20,22,24,27,28,30,32,34,36,40,41,46,48,51,54,56}. Here rules are labeled as follows: DPs: { 1: +^#(@x, @y) -> c_1(#add^#(@x, @y)) , 2: and^#(@x, @y) -> c_2(#and^#(@x, @y)) , 3: append^#(@l, @ys) -> c_3(append#1^#(@l, @ys)) , 4: append#1^#(::(@x, @xs), @ys) -> c_4(append#2^#(append(@xs, @ys), @x), append^#(@xs, @ys)) , 5: append#1^#(nil(), @ys) -> c_5() , 6: append#2^#(@l', @x) -> c_6() , 7: bitonicMerge^#(@l, @direction) -> c_7(bitonicMerge#1^#(@l, @direction, @l)) , 8: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_8(bitonicMerge#2^#(@xs, @direction, @l)) , 9: bitonicMerge#1^#(nil(), @direction, @l) -> c_9() , 10: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , 11: bitonicMerge#2^#(nil(), @direction, @l) -> c_11() , 12: bitonicMerge#3^#(@h, @direction, @l) -> c_16(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , 13: div2^#(@n) -> c_15(div2#1^#(@n)) , 14: length^#(@l) -> c_14(length#1^#(@l)) , 15: bitonicMerge#10^#(#false(), @hi, @low) -> c_12() , 16: bitonicMerge#10^#(#true(), @hi, @low) -> c_13() , 17: length#1^#(::(@x, @xs)) -> c_37(+^#(#pos(#s(#0())), length(@xs)), length^#(@xs)) , 18: length#1^#(nil()) -> c_38() , 19: div2#1^#(#0()) -> c_33() , 20: div2#1^#(#s(@n)) -> c_34(div2#2^#(@n)) , 21: bitonicMerge#4^#(@s, @direction) -> c_18(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , 22: splitAt^#(@n, @l) -> c_17(splitAt#1^#(@n, @l)) , 23: splitAt#1^#(#0(), @l) -> c_45() , 24: splitAt#1^#(#s(@n'), @l) -> c_46(splitAt#2^#(@l, @n')) , 25: bitonicMerge#5^#(@hi, @direction, @s) -> c_20(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , 26: bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_19(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , 27: zipWithOr^#(@l1, @l2) -> c_23(zipWithOr#1^#(@l1, @l2)) , 28: bitonicMerge#7^#(@low, @direction, @hi) -> c_22(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction), bitonicMerge#10^#(@direction, @hi, @low)) , 29: bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_21(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , 30: zipWithAnd^#(@l1, @l2) -> c_25(zipWithAnd#1^#(@l1, @l2)) , 31: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_24(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , 32: zipWithOr#1^#(::(@x, @xs), @l2) -> c_54(zipWithOr#2^#(@l2, @x, @xs)) , 33: zipWithOr#1^#(nil(), @l2) -> c_55() , 34: zipWithAnd#1^#(::(@x, @xs), @l2) -> c_50(zipWithAnd#2^#(@l2, @x, @xs)) , 35: zipWithAnd#1^#(nil(), @l2) -> c_51() , 36: bitonicSort^#(@l, @dir) -> c_26(bitonicSort#1^#(@l, @dir, @l)) , 37: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_27(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , 38: bitonicSort#1^#(nil(), @dir, @l) -> c_28() , 39: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_30(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , 40: split^#(@l) -> c_29(split#1^#(@l)) , 41: split#1^#(::(@x1, @xs)) -> c_40(split#2^#(@xs, @x1)) , 42: split#1^#(nil()) -> c_41() , 43: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_31(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , 44: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_32(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , 45: div2#2^#(#0()) -> c_35() , 46: div2#2^#(#s(@n)) -> c_36(+^#(#pos(#s(#0())), div2(@n)), div2^#(@n)) , 47: or^#(@x, @y) -> c_39(#or^#(@x, @y)) , 48: split#2^#(::(@x2, @xs'), @x1) -> c_42(split#3^#(split(@xs'), @x1, @x2), split^#(@xs')) , 49: split#2^#(nil(), @x1) -> c_43() , 50: split#3^#(tuple#2(@l1, @l2), @x1, @x2) -> c_44() , 51: splitAt#2^#(::(@x, @xs), @n') -> c_47(splitAt#3^#(splitAt(@n', @xs), @x), splitAt^#(@n', @xs)) , 52: splitAt#2^#(nil(), @n') -> c_48() , 53: splitAt#3^#(tuple#2(@l1, @l2), @x) -> c_49() , 54: zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_52(and^#(@x, @y), zipWithAnd^#(@xs, @ys)) , 55: zipWithAnd#2^#(nil(), @x, @xs) -> c_53() , 56: zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_56(or^#(@x, @y), zipWithOr^#(@xs, @ys)) , 57: zipWithOr#2^#(nil(), @x, @xs) -> c_57() , 58: #add^#(#0(), @y) -> c_58() , 59: #add^#(#pos(#s(#0())), @y) -> c_59(#succ^#(@y)) , 60: #add^#(#pos(#s(#s(@x))), @y) -> c_60(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 61: #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , 62: #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , 63: #and^#(#false(), #false()) -> c_63() , 64: #and^#(#false(), #true()) -> c_64() , 65: #and^#(#true(), #false()) -> c_65() , 66: #and^#(#true(), #true()) -> c_66() , 67: #or^#(#false(), #false()) -> c_67() , 68: #or^#(#false(), #true()) -> c_68() , 69: #or^#(#true(), #false()) -> c_69() , 70: #or^#(#true(), #true()) -> c_70() , 71: #succ^#(#0()) -> c_75() , 72: #succ^#(#pos(#s(@x))) -> c_76() , 73: #succ^#(#neg(#s(#0()))) -> c_77() , 74: #succ^#(#neg(#s(#s(@x)))) -> c_78() , 75: #pred^#(#0()) -> c_71() , 76: #pred^#(#pos(#s(#0()))) -> c_72() , 77: #pred^#(#pos(#s(#s(@x)))) -> c_73() , 78: #pred^#(#neg(#s(@x))) -> c_74() } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { append^#(@l, @ys) -> c_3(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_4(append#2^#(append(@xs, @ys), @x), append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_7(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_8(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_16(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_15(div2#1^#(@n)) , length^#(@l) -> c_14(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_37(+^#(#pos(#s(#0())), length(@xs)), length^#(@xs)) , div2#1^#(#s(@n)) -> c_34(div2#2^#(@n)) , bitonicMerge#4^#(@s, @direction) -> c_18(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_17(splitAt#1^#(@n, @l)) , splitAt#1^#(#s(@n'), @l) -> c_46(splitAt#2^#(@l, @n')) , bitonicMerge#5^#(@hi, @direction, @s) -> c_20(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_19(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_23(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_22(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction), bitonicMerge#10^#(@direction, @hi, @low)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_21(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_25(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_24(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_54(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_50(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_26(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_27(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_30(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , split^#(@l) -> c_29(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_40(split#2^#(@xs, @x1)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_31(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_32(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , div2#2^#(#s(@n)) -> c_36(+^#(#pos(#s(#0())), div2(@n)), div2^#(@n)) , split#2^#(::(@x2, @xs'), @x1) -> c_42(split#3^#(split(@xs'), @x1, @x2), split^#(@xs')) , splitAt#2^#(::(@x, @xs), @n') -> c_47(splitAt#3^#(splitAt(@n', @xs), @x), splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_52(and^#(@x, @y), zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_56(or^#(@x, @y), zipWithOr^#(@xs, @ys)) } Weak DPs: { +^#(@x, @y) -> c_1(#add^#(@x, @y)) , #add^#(#0(), @y) -> c_58() , #add^#(#pos(#s(#0())), @y) -> c_59(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_60(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , and^#(@x, @y) -> c_2(#and^#(@x, @y)) , #and^#(#false(), #false()) -> c_63() , #and^#(#false(), #true()) -> c_64() , #and^#(#true(), #false()) -> c_65() , #and^#(#true(), #true()) -> c_66() , append#1^#(nil(), @ys) -> c_5() , append#2^#(@l', @x) -> c_6() , bitonicMerge#1^#(nil(), @direction, @l) -> c_9() , bitonicMerge#2^#(nil(), @direction, @l) -> c_11() , bitonicMerge#10^#(#false(), @hi, @low) -> c_12() , bitonicMerge#10^#(#true(), @hi, @low) -> c_13() , length#1^#(nil()) -> c_38() , div2#1^#(#0()) -> c_33() , splitAt#1^#(#0(), @l) -> c_45() , zipWithOr#1^#(nil(), @l2) -> c_55() , zipWithAnd#1^#(nil(), @l2) -> c_51() , bitonicSort#1^#(nil(), @dir, @l) -> c_28() , split#1^#(nil()) -> c_41() , div2#2^#(#0()) -> c_35() , or^#(@x, @y) -> c_39(#or^#(@x, @y)) , #or^#(#false(), #false()) -> c_67() , #or^#(#false(), #true()) -> c_68() , #or^#(#true(), #false()) -> c_69() , #or^#(#true(), #true()) -> c_70() , split#2^#(nil(), @x1) -> c_43() , split#3^#(tuple#2(@l1, @l2), @x1, @x2) -> c_44() , splitAt#2^#(nil(), @n') -> c_48() , splitAt#3^#(tuple#2(@l1, @l2), @x) -> c_49() , zipWithAnd#2^#(nil(), @x, @xs) -> c_53() , zipWithOr#2^#(nil(), @x, @xs) -> c_57() , #succ^#(#0()) -> c_75() , #succ^#(#pos(#s(@x))) -> c_76() , #succ^#(#neg(#s(#0()))) -> c_77() , #succ^#(#neg(#s(#s(@x)))) -> c_78() , #pred^#(#0()) -> c_71() , #pred^#(#pos(#s(#0()))) -> c_72() , #pred^#(#pos(#s(#s(@x)))) -> c_73() , #pred^#(#neg(#s(@x))) -> c_74() } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { +^#(@x, @y) -> c_1(#add^#(@x, @y)) , #add^#(#0(), @y) -> c_58() , #add^#(#pos(#s(#0())), @y) -> c_59(#succ^#(@y)) , #add^#(#pos(#s(#s(@x))), @y) -> c_60(#succ^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , #add^#(#neg(#s(#0())), @y) -> c_61(#pred^#(@y)) , #add^#(#neg(#s(#s(@x))), @y) -> c_62(#pred^#(#add(#pos(#s(@x)), @y)), #add^#(#pos(#s(@x)), @y)) , and^#(@x, @y) -> c_2(#and^#(@x, @y)) , #and^#(#false(), #false()) -> c_63() , #and^#(#false(), #true()) -> c_64() , #and^#(#true(), #false()) -> c_65() , #and^#(#true(), #true()) -> c_66() , append#1^#(nil(), @ys) -> c_5() , append#2^#(@l', @x) -> c_6() , bitonicMerge#1^#(nil(), @direction, @l) -> c_9() , bitonicMerge#2^#(nil(), @direction, @l) -> c_11() , bitonicMerge#10^#(#false(), @hi, @low) -> c_12() , bitonicMerge#10^#(#true(), @hi, @low) -> c_13() , length#1^#(nil()) -> c_38() , div2#1^#(#0()) -> c_33() , splitAt#1^#(#0(), @l) -> c_45() , zipWithOr#1^#(nil(), @l2) -> c_55() , zipWithAnd#1^#(nil(), @l2) -> c_51() , bitonicSort#1^#(nil(), @dir, @l) -> c_28() , split#1^#(nil()) -> c_41() , div2#2^#(#0()) -> c_35() , or^#(@x, @y) -> c_39(#or^#(@x, @y)) , #or^#(#false(), #false()) -> c_67() , #or^#(#false(), #true()) -> c_68() , #or^#(#true(), #false()) -> c_69() , #or^#(#true(), #true()) -> c_70() , split#2^#(nil(), @x1) -> c_43() , split#3^#(tuple#2(@l1, @l2), @x1, @x2) -> c_44() , splitAt#2^#(nil(), @n') -> c_48() , splitAt#3^#(tuple#2(@l1, @l2), @x) -> c_49() , zipWithAnd#2^#(nil(), @x, @xs) -> c_53() , zipWithOr#2^#(nil(), @x, @xs) -> c_57() , #succ^#(#0()) -> c_75() , #succ^#(#pos(#s(@x))) -> c_76() , #succ^#(#neg(#s(#0()))) -> c_77() , #succ^#(#neg(#s(#s(@x)))) -> c_78() , #pred^#(#0()) -> c_71() , #pred^#(#pos(#s(#0()))) -> c_72() , #pred^#(#pos(#s(#s(@x)))) -> c_73() , #pred^#(#neg(#s(@x))) -> c_74() } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { append^#(@l, @ys) -> c_3(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_4(append#2^#(append(@xs, @ys), @x), append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_7(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_8(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_16(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_15(div2#1^#(@n)) , length^#(@l) -> c_14(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_37(+^#(#pos(#s(#0())), length(@xs)), length^#(@xs)) , div2#1^#(#s(@n)) -> c_34(div2#2^#(@n)) , bitonicMerge#4^#(@s, @direction) -> c_18(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_17(splitAt#1^#(@n, @l)) , splitAt#1^#(#s(@n'), @l) -> c_46(splitAt#2^#(@l, @n')) , bitonicMerge#5^#(@hi, @direction, @s) -> c_20(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_19(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_23(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_22(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction), bitonicMerge#10^#(@direction, @hi, @low)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_21(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_25(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_24(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_54(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_50(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_26(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_27(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_30(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , split^#(@l) -> c_29(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_40(split#2^#(@xs, @x1)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_31(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_32(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , div2#2^#(#s(@n)) -> c_36(+^#(#pos(#s(#0())), div2(@n)), div2^#(@n)) , split#2^#(::(@x2, @xs'), @x1) -> c_42(split#3^#(split(@xs'), @x1, @x2), split^#(@xs')) , splitAt#2^#(::(@x, @xs), @n') -> c_47(splitAt#3^#(splitAt(@n', @xs), @x), splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_52(and^#(@x, @y), zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_56(or^#(@x, @y), zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { append#1^#(::(@x, @xs), @ys) -> c_4(append#2^#(append(@xs, @ys), @x), append^#(@xs, @ys)) , length#1^#(::(@x, @xs)) -> c_37(+^#(#pos(#s(#0())), length(@xs)), length^#(@xs)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_22(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction), bitonicMerge#10^#(@direction, @hi, @low)) , div2#2^#(#s(@n)) -> c_36(+^#(#pos(#s(#0())), div2(@n)), div2^#(@n)) , split#2^#(::(@x2, @xs'), @x1) -> c_42(split#3^#(split(@xs'), @x1, @x2), split^#(@xs')) , splitAt#2^#(::(@x, @xs), @n') -> c_47(splitAt#3^#(splitAt(@n', @xs), @x), splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_52(and^#(@x, @y), zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_56(or^#(@x, @y), zipWithOr^#(@xs, @ys)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_23(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , split^#(@l) -> c_26(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 13: splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) } Trs: { append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , length(@l) -> length#1(@l) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1, 2, 3}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1, 2}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1, 2}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1, 2, 3}, Uargs(c_21) = {1}, Uargs(c_22) = {1}, Uargs(c_23) = {1}, Uargs(c_24) = {1, 2}, Uargs(c_25) = {1, 2}, Uargs(c_26) = {1}, Uargs(c_27) = {1}, Uargs(c_28) = {1, 2}, Uargs(c_29) = {1, 2}, Uargs(c_30) = {1}, Uargs(c_31) = {1}, Uargs(c_32) = {1}, Uargs(c_33) = {1}, Uargs(c_34) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [1] x2 + [0] [#add](x1, x2) = [1] x2 + [0] [and](x1, x2) = [0] [#and](x1, x2) = [1] x1 + [1] x2 + [0] [append](x1, x2) = [0] [append#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x2 + [1] [append#2](x1, x2) = [0] [nil] = [0] [bitonicMerge](x1, x2) = [1] x1 + [0] [bitonicMerge#1](x1, x2, x3) = [1] x3 + [1] [bitonicMerge#2](x1, x2, x3) = [1] x1 + [1] x3 + [0] [#false] = [0] [bitonicMerge#10](x1, x2, x3) = [1] [tuple#2](x1, x2) = [1] x2 + [1] [#true] = [0] [length](x1) = [1] x1 + [1] [div2](x1) = [0] [bitonicMerge#3](x1, x2, x3) = [0] [splitAt](x1, x2) = [0] [bitonicMerge#4](x1, x2) = [0] [bitonicMerge#6](x1) = [0] [bitonicMerge#5](x1, x2, x3) = [0] [bitonicMerge#8](x1) = [1] x1 + [0] [bitonicMerge#7](x1, x2, x3) = [0] [zipWithOr](x1, x2) = [0] [bitonicMerge#9](x1, x2) = [0] [zipWithAnd](x1, x2) = [1] x2 + [0] [bitonicSort](x1, x2) = [0] [bitonicSort#1](x1, x2, x3) = [1] [split](x1) = [0] [bitonicSort#2](x1, x2) = [1] x1 + [0] [bitonicSort#3](x1, x2, x3, x4) = [0] [bitonicSort#4](x1, x2, x3, x4) = [0] [div2#1](x1) = [0] [#0] = [0] [#s](x1) = [1] x1 + [1] [div2#2](x1) = [0] [#pos](x1) = [0] [length#1](x1) = [1] x1 + [0] [or](x1, x2) = [0] [#or](x1, x2) = [1] x1 + [1] x2 + [0] [split#1](x1) = [0] [split#2](x1, x2) = [0] [split#3](x1, x2, x3) = [1] x1 + [0] [splitAt#1](x1, x2) = [1] x1 + [1] x2 + [1] [splitAt#2](x1, x2) = [0] [splitAt#3](x1, x2) = [0] [zipWithAnd#1](x1, x2) = [1] x2 + [0] [zipWithAnd#2](x1, x2, x3) = [1] x1 + [0] [zipWithOr#1](x1, x2) = [1] [zipWithOr#2](x1, x2, x3) = [0] [#neg](x1) = [0] [#pred](x1) = [1] x1 + [0] [#succ](x1) = [1] x1 + [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [and^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [append^#](x1, x2) = [0] [append#1^#](x1, x2) = [0] [append#2^#](x1, x2) = [0] [bitonicMerge^#](x1, x2) = [0] [bitonicMerge#1^#](x1, x2, x3) = [0] [bitonicMerge#2^#](x1, x2, x3) = [0] [bitonicMerge#3^#](x1, x2, x3) = [1] x1 + [0] [div2^#](x1) = [0] [length^#](x1) = [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [length#1^#](x1) = [0] [div2#1^#](x1) = [0] [bitonicMerge#4^#](x1, x2) = [0] [splitAt^#](x1, x2) = [1] x1 + [0] [splitAt#1^#](x1, x2) = [1] x1 + [0] [bitonicMerge#5^#](x1, x2, x3) = [0] [bitonicMerge#6^#](x1) = [0] [zipWithOr^#](x1, x2) = [0] [bitonicMerge#7^#](x1, x2, x3) = [0] [bitonicMerge#8^#](x1) = [0] [zipWithAnd^#](x1, x2) = [0] [bitonicMerge#9^#](x1, x2) = [0] [zipWithOr#1^#](x1, x2) = [0] [zipWithAnd#1^#](x1, x2) = [0] [bitonicSort^#](x1, x2) = [0] [bitonicSort#1^#](x1, x2, x3) = [0] [bitonicSort#2^#](x1, x2) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [bitonicSort#3^#](x1, x2, x3, x4) = [0] [bitonicSort#4^#](x1, x2, x3, x4) = [0] [div2#2^#](x1) = [0] [or^#](x1, x2) = [0] [#or^#](x1, x2) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [splitAt#2^#](x1, x2) = [1] x2 + [0] [splitAt#3^#](x1, x2) = [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [zipWithOr#2^#](x1, x2, x3) = [0] [#succ^#](x1) = [0] [#pred^#](x1) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_6](x1, x2) = [1] x1 + [1] x2 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1, x2) = [1] x1 + [1] x2 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1, x2) = [1] x1 + [1] x2 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] [c_19](x1) = [1] x1 + [0] [c_20](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_21](x1) = [1] x1 + [0] [c_22](x1) = [1] x1 + [0] [c_23](x1) = [1] x1 + [0] [c_24](x1, x2) = [1] x1 + [1] x2 + [0] [c_25](x1, x2) = [1] x1 + [1] x2 + [0] [c_26](x1) = [1] x1 + [0] [c_27](x1) = [1] x1 + [0] [c_28](x1, x2) = [1] x1 + [1] x2 + [0] [c_29](x1, x2) = [1] x1 + [1] x2 + [0] [c_30](x1) = [1] x1 + [0] [c_31](x1) = [1] x1 + [0] [c_32](x1) = [1] x1 + [0] [c_33](x1) = [1] x1 + [0] [c_34](x1) = [1] x1 + [0] This order satisfies following ordering constraints [+(@x, @y)] = [1] @y + [0] >= [1] @y + [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1] @y + [0] >= [1] @y + [0] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1] @y + [0] >= [1] @y + [0] = [#pred(#add(#pos(#s(@x)), @y))] [length(@l)] = [1] @l + [1] > [1] @l + [0] = [length#1(@l)] [div2(@n)] = [0] >= [0] = [div2#1(@n)] [zipWithAnd(@l1, @l2)] = [1] @l2 + [0] >= [1] @l2 + [0] = [zipWithAnd#1(@l1, @l2)] [div2#1(#0())] = [0] >= [0] = [#0()] [div2#1(#s(@n))] = [0] >= [0] = [div2#2(@n)] [div2#2(#0())] = [0] >= [0] = [#0()] [div2#2(#s(@n))] = [0] >= [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [1] @xs + [1] >= [1] @xs + [1] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [0] >= [0] = [#0()] [zipWithAnd#1(::(@x, @xs), @l2)] = [1] @l2 + [0] >= [1] @l2 + [0] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [1] @l2 + [0] >= [0] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [1] @ys + [1] >= [1] @ys + [1] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [0] >= [0] = [nil()] [#pred(#0())] = [0] >= [0] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [0] >= [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [0] >= [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [0] >= [0] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] >= [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] >= [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [0] >= [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [0] >= [0] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] >= [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] >= [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [0] >= [0] = [c_3(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [0] >= [0] = [c_4(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [0] >= [0] = [c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l))] [bitonicMerge#3^#(@h, @direction, @l)] = [1] @h + [0] >= [1] @h + [0] = [c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l))] [div2^#(@n)] = [0] >= [0] = [c_7(div2#1^#(@n))] [length^#(@l)] = [0] >= [0] = [c_8(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] >= [0] = [c_9(length^#(@xs))] [div2#1^#(#s(@n))] = [0] >= [0] = [c_10(div2#2^#(@n))] [bitonicMerge#4^#(@s, @direction)] = [0] >= [0] = [c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s))] [splitAt^#(@n, @l)] = [1] @n + [0] >= [1] @n + [0] = [c_12(splitAt#1^#(@n, @l))] [splitAt#1^#(#s(@n'), @l)] = [1] @n' + [1] > [1] @n' + [0] = [c_13(splitAt#2^#(@l, @n'))] [bitonicMerge#5^#(@hi, @direction, @s)] = [0] >= [0] = [c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s))] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0] >= [0] = [c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [0] >= [0] = [c_16(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [0] >= [0] = [c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0] >= [0] = [c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [0] >= [0] = [c_19(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [0] >= [0] = [c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [zipWithOr#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_21(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_22(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [0] >= [0] = [c_23(bitonicSort#1^#(@l, @dir, @l))] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [0] >= [0] = [c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [0] >= [0] = [c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true()))] [split^#(@l)] = [0] >= [0] = [c_26(split#1^#(@l))] [split#1^#(::(@x1, @xs))] = [0] >= [0] = [c_27(split#2^#(@xs, @x1))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [0] >= [0] = [c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false()))] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [0] >= [0] = [c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2))] [div2#2^#(#s(@n))] = [0] >= [0] = [c_30(div2^#(@n))] [split#2^#(::(@x2, @xs'), @x1)] = [0] >= [0] = [c_31(split^#(@xs'))] [splitAt#2^#(::(@x, @xs), @n')] = [1] @n' + [0] >= [1] @n' + [0] = [c_32(splitAt^#(@n', @xs))] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_33(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_34(zipWithOr^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , 2: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , 3: bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , 4: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , 5: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , 6: bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , 7: div2^#(@n) -> c_7(div2#1^#(@n)) , 8: length^#(@l) -> c_8(length#1^#(@l)) , 9: length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , 10: div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , 11: bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , 12: splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , 13: splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , 14: bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , 15: bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , 16: zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , 17: bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , 18: bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , 19: zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , 20: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , 21: zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , 22: zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , 23: bitonicSort^#(@l, @dir) -> c_23(bitonicSort#1^#(@l, @dir, @l)) , 24: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , 25: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , 26: split^#(@l) -> c_26(split#1^#(@l)) , 27: split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , 28: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , 29: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , 30: div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , 31: split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , 32: splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , 33: zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , 34: zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {13}. These cover all (indirect) predecessors of dependency pairs {13,32}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_23(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , split^#(@l) -> c_26(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak DPs: { splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 29: div2#2^#(#s(@n)) -> c_30(div2^#(@n)) } Trs: { append#1(nil(), @ys) -> @ys , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1, 2, 3}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1, 2}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1, 2}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1, 2, 3}, Uargs(c_21) = {1}, Uargs(c_22) = {1}, Uargs(c_23) = {1}, Uargs(c_24) = {1, 2}, Uargs(c_25) = {1, 2}, Uargs(c_26) = {1}, Uargs(c_27) = {1}, Uargs(c_28) = {1, 2}, Uargs(c_29) = {1, 2}, Uargs(c_30) = {1}, Uargs(c_31) = {1}, Uargs(c_32) = {1}, Uargs(c_33) = {1}, Uargs(c_34) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [1] x1 + [1] x2 + [0] [#add](x1, x2) = [1] x1 + [1] x2 + [0] [and](x1, x2) = [0] [#and](x1, x2) = [1] x1 + [1] x2 + [0] [append](x1, x2) = [1] x1 + [1] x2 + [0] [append#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x2 + [1] [append#2](x1, x2) = [1] x1 + [1] [nil] = [1] [bitonicMerge](x1, x2) = [1] [bitonicMerge#1](x1, x2, x3) = [1] x3 + [1] [bitonicMerge#2](x1, x2, x3) = [1] x1 + [1] x3 + [0] [#false] = [0] [bitonicMerge#10](x1, x2, x3) = [0] [tuple#2](x1, x2) = [1] [#true] = [0] [length](x1) = [0] [div2](x1) = [0] [bitonicMerge#3](x1, x2, x3) = [0] [splitAt](x1, x2) = [1] x1 + [0] [bitonicMerge#4](x1, x2) = [0] [bitonicMerge#6](x1) = [0] [bitonicMerge#5](x1, x2, x3) = [0] [bitonicMerge#8](x1) = [1] x1 + [1] [bitonicMerge#7](x1, x2, x3) = [0] [zipWithOr](x1, x2) = [0] [bitonicMerge#9](x1, x2) = [1] x1 + [0] [zipWithAnd](x1, x2) = [1] x1 + [0] [bitonicSort](x1, x2) = [1] x1 + [0] [bitonicSort#1](x1, x2, x3) = [1] [split](x1) = [1] [bitonicSort#2](x1, x2) = [0] [bitonicSort#3](x1, x2, x3, x4) = [0] [bitonicSort#4](x1, x2, x3, x4) = [0] [div2#1](x1) = [0] [#0] = [0] [#s](x1) = [1] x1 + [1] [div2#2](x1) = [0] [#pos](x1) = [0] [length#1](x1) = [0] [or](x1, x2) = [0] [#or](x1, x2) = [1] x1 + [1] x2 + [0] [split#1](x1) = [1] [split#2](x1, x2) = [1] [split#3](x1, x2, x3) = [1] [splitAt#1](x1, x2) = [1] x1 + [1] x2 + [1] [splitAt#2](x1, x2) = [1] [splitAt#3](x1, x2) = [0] [zipWithAnd#1](x1, x2) = [1] x1 + [0] [zipWithAnd#2](x1, x2, x3) = [1] x3 + [1] [zipWithOr#1](x1, x2) = [1] [zipWithOr#2](x1, x2, x3) = [1] [#neg](x1) = [0] [#pred](x1) = [0] [#succ](x1) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [and^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [append^#](x1, x2) = [0] [append#1^#](x1, x2) = [0] [append#2^#](x1, x2) = [0] [bitonicMerge^#](x1, x2) = [0] [bitonicMerge#1^#](x1, x2, x3) = [0] [bitonicMerge#2^#](x1, x2, x3) = [0] [bitonicMerge#3^#](x1, x2, x3) = [1] x1 + [0] [div2^#](x1) = [1] x1 + [0] [length^#](x1) = [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [length#1^#](x1) = [0] [div2#1^#](x1) = [1] x1 + [0] [bitonicMerge#4^#](x1, x2) = [0] [splitAt^#](x1, x2) = [0] [splitAt#1^#](x1, x2) = [0] [bitonicMerge#5^#](x1, x2, x3) = [0] [bitonicMerge#6^#](x1) = [0] [zipWithOr^#](x1, x2) = [0] [bitonicMerge#7^#](x1, x2, x3) = [0] [bitonicMerge#8^#](x1) = [0] [zipWithAnd^#](x1, x2) = [0] [bitonicMerge#9^#](x1, x2) = [0] [zipWithOr#1^#](x1, x2) = [0] [zipWithAnd#1^#](x1, x2) = [0] [bitonicSort^#](x1, x2) = [0] [bitonicSort#1^#](x1, x2, x3) = [0] [bitonicSort#2^#](x1, x2) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [bitonicSort#3^#](x1, x2, x3, x4) = [0] [bitonicSort#4^#](x1, x2, x3, x4) = [0] [div2#2^#](x1) = [1] x1 + [1] [or^#](x1, x2) = [0] [#or^#](x1, x2) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [splitAt#2^#](x1, x2) = [0] [splitAt#3^#](x1, x2) = [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [zipWithOr#2^#](x1, x2, x3) = [0] [#succ^#](x1) = [0] [#pred^#](x1) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_6](x1, x2) = [1] x1 + [1] x2 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1, x2) = [1] x1 + [1] x2 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1, x2) = [1] x1 + [1] x2 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] [c_19](x1) = [1] x1 + [0] [c_20](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_21](x1) = [1] x1 + [0] [c_22](x1) = [1] x1 + [0] [c_23](x1) = [1] x1 + [0] [c_24](x1, x2) = [1] x1 + [1] x2 + [0] [c_25](x1, x2) = [1] x1 + [1] x2 + [0] [c_26](x1) = [1] x1 + [0] [c_27](x1) = [1] x1 + [0] [c_28](x1, x2) = [1] x1 + [1] x2 + [0] [c_29](x1, x2) = [1] x1 + [1] x2 + [0] [c_30](x1) = [1] x1 + [1] [c_31](x1) = [1] x1 + [0] [c_32](x1) = [1] x1 + [0] [c_33](x1) = [1] x1 + [0] [c_34](x1) = [1] x1 + [0] This order satisfies following ordering constraints [+(@x, @y)] = [1] @x + [1] @y + [0] >= [1] @x + [1] @y + [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1] @y + [0] >= [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1] @y + [0] >= [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1] @y + [0] >= [0] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1] @y + [0] >= [0] = [#pred(#add(#pos(#s(@x)), @y))] [append(@l, @ys)] = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [1] @xs + [1] @ys + [1] >= [1] @xs + [1] @ys + [1] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [1] @ys + [1] > [1] @ys + [0] = [@ys] [append#2(@l', @x)] = [1] @l' + [1] >= [1] @l' + [1] = [::(@x, @l')] [length(@l)] = [0] >= [0] = [length#1(@l)] [div2(@n)] = [0] >= [0] = [div2#1(@n)] [zipWithAnd(@l1, @l2)] = [1] @l1 + [0] >= [1] @l1 + [0] = [zipWithAnd#1(@l1, @l2)] [split(@l)] = [1] >= [1] = [split#1(@l)] [div2#1(#0())] = [0] >= [0] = [#0()] [div2#1(#s(@n))] = [0] >= [0] = [div2#2(@n)] [div2#2(#0())] = [0] >= [0] = [#0()] [div2#2(#s(@n))] = [0] >= [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [0] >= [0] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [0] >= [0] = [#0()] [split#1(::(@x1, @xs))] = [1] >= [1] = [split#2(@xs, @x1)] [split#1(nil())] = [1] >= [1] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [1] >= [1] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [1] >= [1] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [1] >= [1] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [zipWithAnd#1(::(@x, @xs), @l2)] = [1] @xs + [1] >= [1] @xs + [1] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [1] >= [1] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [1] @xs + [1] >= [1] @xs + [1] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [1] @xs + [1] >= [1] = [nil()] [#pred(#0())] = [0] >= [0] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [0] >= [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [0] >= [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [0] >= [0] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] >= [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] >= [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [0] >= [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [0] >= [0] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] >= [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] >= [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [0] >= [0] = [c_3(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [0] >= [0] = [c_4(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [0] >= [0] = [c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l))] [bitonicMerge#3^#(@h, @direction, @l)] = [1] @h + [0] >= [0] = [c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l))] [div2^#(@n)] = [1] @n + [0] >= [1] @n + [0] = [c_7(div2#1^#(@n))] [length^#(@l)] = [0] >= [0] = [c_8(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] >= [0] = [c_9(length^#(@xs))] [div2#1^#(#s(@n))] = [1] @n + [1] >= [1] @n + [1] = [c_10(div2#2^#(@n))] [bitonicMerge#4^#(@s, @direction)] = [0] >= [0] = [c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s))] [splitAt^#(@n, @l)] = [0] >= [0] = [c_12(splitAt#1^#(@n, @l))] [splitAt#1^#(#s(@n'), @l)] = [0] >= [0] = [c_13(splitAt#2^#(@l, @n'))] [bitonicMerge#5^#(@hi, @direction, @s)] = [0] >= [0] = [c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s))] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0] >= [0] = [c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [0] >= [0] = [c_16(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [0] >= [0] = [c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0] >= [0] = [c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [0] >= [0] = [c_19(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [0] >= [0] = [c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [zipWithOr#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_21(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_22(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [0] >= [0] = [c_23(bitonicSort#1^#(@l, @dir, @l))] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [0] >= [0] = [c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [0] >= [0] = [c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true()))] [split^#(@l)] = [0] >= [0] = [c_26(split#1^#(@l))] [split#1^#(::(@x1, @xs))] = [0] >= [0] = [c_27(split#2^#(@xs, @x1))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [0] >= [0] = [c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false()))] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [0] >= [0] = [c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2))] [div2#2^#(#s(@n))] = [1] @n + [2] > [1] @n + [1] = [c_30(div2^#(@n))] [split#2^#(::(@x2, @xs'), @x1)] = [0] >= [0] = [c_31(split^#(@xs'))] [splitAt#2^#(::(@x, @xs), @n')] = [0] >= [0] = [c_32(splitAt^#(@n', @xs))] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_33(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_34(zipWithOr^#(@xs, @ys))] The strictly oriented rules are moved into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_23(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , split^#(@l) -> c_26(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak DPs: { splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 10: div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , 33: div2#2^#(#s(@n)) -> c_30(div2^#(@n)) } Trs: { bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1, 2, 3}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1, 2}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1, 2}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1, 2, 3}, Uargs(c_21) = {1}, Uargs(c_22) = {1}, Uargs(c_23) = {1}, Uargs(c_24) = {1, 2}, Uargs(c_25) = {1, 2}, Uargs(c_26) = {1}, Uargs(c_27) = {1}, Uargs(c_28) = {1, 2}, Uargs(c_29) = {1, 2}, Uargs(c_30) = {1}, Uargs(c_31) = {1}, Uargs(c_32) = {1}, Uargs(c_33) = {1}, Uargs(c_34) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [1] x2 + [0] [#add](x1, x2) = [1] x2 + [0] [and](x1, x2) = [0] [#and](x1, x2) = [1] x1 + [1] x2 + [0] [append](x1, x2) = [1] x1 + [1] x2 + [0] [append#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x2 + [1] [append#2](x1, x2) = [1] x1 + [1] [nil] = [0] [bitonicMerge](x1, x2) = [1] x1 + [0] [bitonicMerge#1](x1, x2, x3) = [1] x3 + [1] [bitonicMerge#2](x1, x2, x3) = [1] x1 + [1] x3 + [0] [#false] = [0] [bitonicMerge#10](x1, x2, x3) = [1] [tuple#2](x1, x2) = [1] [#true] = [0] [length](x1) = [0] [div2](x1) = [1] x1 + [0] [bitonicMerge#3](x1, x2, x3) = [0] [splitAt](x1, x2) = [1] x1 + [0] [bitonicMerge#4](x1, x2) = [0] [bitonicMerge#6](x1) = [0] [bitonicMerge#5](x1, x2, x3) = [0] [bitonicMerge#8](x1) = [0] [bitonicMerge#7](x1, x2, x3) = [0] [zipWithOr](x1, x2) = [0] [bitonicMerge#9](x1, x2) = [1] x1 + [0] [zipWithAnd](x1, x2) = [0] [bitonicSort](x1, x2) = [1] x1 + [0] [bitonicSort#1](x1, x2, x3) = [1] [split](x1) = [1] [bitonicSort#2](x1, x2) = [0] [bitonicSort#3](x1, x2, x3, x4) = [0] [bitonicSort#4](x1, x2, x3, x4) = [0] [div2#1](x1) = [1] x1 + [0] [#0] = [0] [#s](x1) = [1] x1 + [1] [div2#2](x1) = [1] x1 + [1] [#pos](x1) = [0] [length#1](x1) = [0] [or](x1, x2) = [0] [#or](x1, x2) = [1] x1 + [1] x2 + [0] [split#1](x1) = [1] [split#2](x1, x2) = [1] [split#3](x1, x2, x3) = [1] x1 + [0] [splitAt#1](x1, x2) = [1] x1 + [1] x2 + [1] [splitAt#2](x1, x2) = [1] [splitAt#3](x1, x2) = [0] [zipWithAnd#1](x1, x2) = [1] [zipWithAnd#2](x1, x2, x3) = [1] [zipWithOr#1](x1, x2) = [1] [zipWithOr#2](x1, x2, x3) = [0] [#neg](x1) = [0] [#pred](x1) = [1] x1 + [0] [#succ](x1) = [1] x1 + [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [and^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [append^#](x1, x2) = [0] [append#1^#](x1, x2) = [0] [append#2^#](x1, x2) = [0] [bitonicMerge^#](x1, x2) = [0] [bitonicMerge#1^#](x1, x2, x3) = [0] [bitonicMerge#2^#](x1, x2, x3) = [0] [bitonicMerge#3^#](x1, x2, x3) = [1] x1 + [0] [div2^#](x1) = [1] x1 + [0] [length^#](x1) = [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [length#1^#](x1) = [0] [div2#1^#](x1) = [1] x1 + [0] [bitonicMerge#4^#](x1, x2) = [0] [splitAt^#](x1, x2) = [0] [splitAt#1^#](x1, x2) = [0] [bitonicMerge#5^#](x1, x2, x3) = [0] [bitonicMerge#6^#](x1) = [0] [zipWithOr^#](x1, x2) = [0] [bitonicMerge#7^#](x1, x2, x3) = [0] [bitonicMerge#8^#](x1) = [0] [zipWithAnd^#](x1, x2) = [0] [bitonicMerge#9^#](x1, x2) = [0] [zipWithOr#1^#](x1, x2) = [0] [zipWithAnd#1^#](x1, x2) = [0] [bitonicSort^#](x1, x2) = [0] [bitonicSort#1^#](x1, x2, x3) = [0] [bitonicSort#2^#](x1, x2) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [bitonicSort#3^#](x1, x2, x3, x4) = [0] [bitonicSort#4^#](x1, x2, x3, x4) = [0] [div2#2^#](x1) = [1] x1 + [0] [or^#](x1, x2) = [0] [#or^#](x1, x2) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [splitAt#2^#](x1, x2) = [0] [splitAt#3^#](x1, x2) = [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [zipWithOr#2^#](x1, x2, x3) = [0] [#succ^#](x1) = [0] [#pred^#](x1) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_6](x1, x2) = [1] x1 + [1] x2 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1, x2) = [1] x1 + [1] x2 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1, x2) = [1] x1 + [1] x2 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] [c_19](x1) = [1] x1 + [0] [c_20](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_21](x1) = [1] x1 + [0] [c_22](x1) = [1] x1 + [0] [c_23](x1) = [1] x1 + [0] [c_24](x1, x2) = [1] x1 + [1] x2 + [0] [c_25](x1, x2) = [1] x1 + [1] x2 + [0] [c_26](x1) = [1] x1 + [0] [c_27](x1) = [1] x1 + [0] [c_28](x1, x2) = [1] x1 + [1] x2 + [0] [c_29](x1, x2) = [1] x1 + [1] x2 + [0] [c_30](x1) = [1] x1 + [0] [c_31](x1) = [1] x1 + [0] [c_32](x1) = [1] x1 + [0] [c_33](x1) = [1] x1 + [0] [c_34](x1) = [1] x1 + [0] This order satisfies following ordering constraints [+(@x, @y)] = [1] @y + [0] >= [1] @y + [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1] @y + [0] >= [1] @y + [0] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1] @y + [0] >= [1] @y + [0] = [#pred(#add(#pos(#s(@x)), @y))] [append(@l, @ys)] = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [1] @xs + [1] @ys + [1] >= [1] @xs + [1] @ys + [1] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [1] @ys + [0] >= [1] @ys + [0] = [@ys] [append#2(@l', @x)] = [1] @l' + [1] >= [1] @l' + [1] = [::(@x, @l')] [length(@l)] = [0] >= [0] = [length#1(@l)] [div2(@n)] = [1] @n + [0] >= [1] @n + [0] = [div2#1(@n)] [split(@l)] = [1] >= [1] = [split#1(@l)] [div2#1(#0())] = [0] >= [0] = [#0()] [div2#1(#s(@n))] = [1] @n + [1] >= [1] @n + [1] = [div2#2(@n)] [div2#2(#0())] = [1] > [0] = [#0()] [div2#2(#s(@n))] = [1] @n + [2] > [1] @n + [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [0] >= [0] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [0] >= [0] = [#0()] [split#1(::(@x1, @xs))] = [1] >= [1] = [split#2(@xs, @x1)] [split#1(nil())] = [1] >= [1] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [1] >= [1] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [1] >= [1] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [1] >= [1] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [#pred(#0())] = [0] >= [0] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [0] >= [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [0] >= [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [0] >= [0] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] >= [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] >= [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [0] >= [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [0] >= [0] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] >= [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] >= [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [0] >= [0] = [c_3(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [0] >= [0] = [c_4(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [0] >= [0] = [c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l))] [bitonicMerge#3^#(@h, @direction, @l)] = [1] @h + [0] >= [0] = [c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l))] [div2^#(@n)] = [1] @n + [0] >= [1] @n + [0] = [c_7(div2#1^#(@n))] [length^#(@l)] = [0] >= [0] = [c_8(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] >= [0] = [c_9(length^#(@xs))] [div2#1^#(#s(@n))] = [1] @n + [1] > [1] @n + [0] = [c_10(div2#2^#(@n))] [bitonicMerge#4^#(@s, @direction)] = [0] >= [0] = [c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s))] [splitAt^#(@n, @l)] = [0] >= [0] = [c_12(splitAt#1^#(@n, @l))] [splitAt#1^#(#s(@n'), @l)] = [0] >= [0] = [c_13(splitAt#2^#(@l, @n'))] [bitonicMerge#5^#(@hi, @direction, @s)] = [0] >= [0] = [c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s))] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0] >= [0] = [c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [0] >= [0] = [c_16(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [0] >= [0] = [c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0] >= [0] = [c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [0] >= [0] = [c_19(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [0] >= [0] = [c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [zipWithOr#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_21(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_22(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [0] >= [0] = [c_23(bitonicSort#1^#(@l, @dir, @l))] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [0] >= [0] = [c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [0] >= [0] = [c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true()))] [split^#(@l)] = [0] >= [0] = [c_26(split#1^#(@l))] [split#1^#(::(@x1, @xs))] = [0] >= [0] = [c_27(split#2^#(@xs, @x1))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [0] >= [0] = [c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false()))] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [0] >= [0] = [c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2))] [div2#2^#(#s(@n))] = [1] @n + [1] > [1] @n + [0] = [c_30(div2^#(@n))] [split#2^#(::(@x2, @xs'), @x1)] = [0] >= [0] = [c_31(split^#(@xs'))] [splitAt#2^#(::(@x, @xs), @n')] = [0] >= [0] = [c_32(splitAt^#(@n', @xs))] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_33(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_34(zipWithOr^#(@xs, @ys))] The strictly oriented rules are moved into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_23(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , split^#(@l) -> c_26(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak DPs: { div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 20: zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) } Trs: { bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(nil(), @x, @xs) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1, 2, 3}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1, 2}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1, 2}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1, 2, 3}, Uargs(c_21) = {1}, Uargs(c_22) = {1}, Uargs(c_23) = {1}, Uargs(c_24) = {1, 2}, Uargs(c_25) = {1, 2}, Uargs(c_26) = {1}, Uargs(c_27) = {1}, Uargs(c_28) = {1, 2}, Uargs(c_29) = {1, 2}, Uargs(c_30) = {1}, Uargs(c_31) = {1}, Uargs(c_32) = {1}, Uargs(c_33) = {1}, Uargs(c_34) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [1] x2 + [0] [#add](x1, x2) = [1] x2 + [0] [and](x1, x2) = [0] [#and](x1, x2) = [1] x1 + [1] x2 + [0] [append](x1, x2) = [1] x1 + [1] x2 + [0] [append#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x2 + [1] [append#2](x1, x2) = [1] x1 + [1] [nil] = [0] [bitonicMerge](x1, x2) = [1] x1 + [0] [bitonicMerge#1](x1, x2, x3) = [1] x3 + [1] [bitonicMerge#2](x1, x2, x3) = [1] x1 + [1] x3 + [0] [#false] = [0] [bitonicMerge#10](x1, x2, x3) = [0] [tuple#2](x1, x2) = [1] x1 + [0] [#true] = [0] [length](x1) = [0] [div2](x1) = [1] x1 + [0] [bitonicMerge#3](x1, x2, x3) = [0] [splitAt](x1, x2) = [1] x1 + [0] [bitonicMerge#4](x1, x2) = [0] [bitonicMerge#6](x1) = [0] [bitonicMerge#5](x1, x2, x3) = [1] x3 + [0] [bitonicMerge#8](x1) = [0] [bitonicMerge#7](x1, x2, x3) = [0] [zipWithOr](x1, x2) = [1] x2 + [1] [bitonicMerge#9](x1, x2) = [1] x1 + [0] [zipWithAnd](x1, x2) = [0] [bitonicSort](x1, x2) = [1] x1 + [0] [bitonicSort#1](x1, x2, x3) = [1] [split](x1) = [1] x1 + [0] [bitonicSort#2](x1, x2) = [0] [bitonicSort#3](x1, x2, x3, x4) = [0] [bitonicSort#4](x1, x2, x3, x4) = [0] [div2#1](x1) = [1] x1 + [0] [#0] = [0] [#s](x1) = [1] x1 + [1] [div2#2](x1) = [1] x1 + [0] [#pos](x1) = [0] [length#1](x1) = [0] [or](x1, x2) = [0] [#or](x1, x2) = [1] x1 + [1] x2 + [0] [split#1](x1) = [1] x1 + [0] [split#2](x1, x2) = [1] x1 + [1] [split#3](x1, x2, x3) = [1] x1 + [1] [splitAt#1](x1, x2) = [1] x1 + [0] [splitAt#2](x1, x2) = [1] x2 + [1] [splitAt#3](x1, x2) = [1] x1 + [1] [zipWithAnd#1](x1, x2) = [1] [zipWithAnd#2](x1, x2, x3) = [1] [zipWithOr#1](x1, x2) = [1] x2 + [1] [zipWithOr#2](x1, x2, x3) = [1] x1 + [1] [#neg](x1) = [0] [#pred](x1) = [0] [#succ](x1) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [and^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [append^#](x1, x2) = [0] [append#1^#](x1, x2) = [0] [append#2^#](x1, x2) = [0] [bitonicMerge^#](x1, x2) = [0] [bitonicMerge#1^#](x1, x2, x3) = [0] [bitonicMerge#2^#](x1, x2, x3) = [0] [bitonicMerge#3^#](x1, x2, x3) = [1] x1 + [0] [div2^#](x1) = [0] [length^#](x1) = [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [length#1^#](x1) = [0] [div2#1^#](x1) = [0] [bitonicMerge#4^#](x1, x2) = [1] x1 + [0] [splitAt^#](x1, x2) = [0] [splitAt#1^#](x1, x2) = [0] [bitonicMerge#5^#](x1, x2, x3) = [1] x3 + [0] [bitonicMerge#6^#](x1) = [0] [zipWithOr^#](x1, x2) = [0] [bitonicMerge#7^#](x1, x2, x3) = [0] [bitonicMerge#8^#](x1) = [1] x1 + [0] [zipWithAnd^#](x1, x2) = [1] x1 + [0] [bitonicMerge#9^#](x1, x2) = [0] [zipWithOr#1^#](x1, x2) = [0] [zipWithAnd#1^#](x1, x2) = [1] x1 + [0] [bitonicSort^#](x1, x2) = [0] [bitonicSort#1^#](x1, x2, x3) = [0] [bitonicSort#2^#](x1, x2) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [bitonicSort#3^#](x1, x2, x3, x4) = [0] [bitonicSort#4^#](x1, x2, x3, x4) = [0] [div2#2^#](x1) = [0] [or^#](x1, x2) = [0] [#or^#](x1, x2) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [splitAt#2^#](x1, x2) = [0] [splitAt#3^#](x1, x2) = [0] [zipWithAnd#2^#](x1, x2, x3) = [1] x3 + [0] [zipWithOr#2^#](x1, x2, x3) = [0] [#succ^#](x1) = [0] [#pred^#](x1) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_6](x1, x2) = [1] x1 + [1] x2 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1, x2) = [1] x1 + [1] x2 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1, x2) = [1] x1 + [1] x2 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] [c_19](x1) = [1] x1 + [0] [c_20](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_21](x1) = [1] x1 + [0] [c_22](x1) = [1] x1 + [0] [c_23](x1) = [1] x1 + [0] [c_24](x1, x2) = [1] x1 + [1] x2 + [0] [c_25](x1, x2) = [1] x1 + [1] x2 + [0] [c_26](x1) = [1] x1 + [0] [c_27](x1) = [1] x1 + [0] [c_28](x1, x2) = [1] x1 + [1] x2 + [0] [c_29](x1, x2) = [1] x1 + [1] x2 + [0] [c_30](x1) = [1] x1 + [0] [c_31](x1) = [1] x1 + [0] [c_32](x1) = [1] x1 + [0] [c_33](x1) = [1] x1 + [0] [c_34](x1) = [1] x1 + [0] This order satisfies following ordering constraints [+(@x, @y)] = [1] @y + [0] >= [1] @y + [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1] @y + [0] >= [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1] @y + [0] >= [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1] @y + [0] >= [0] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1] @y + [0] >= [0] = [#pred(#add(#pos(#s(@x)), @y))] [append(@l, @ys)] = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [1] @xs + [1] @ys + [1] >= [1] @xs + [1] @ys + [1] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [1] @ys + [0] >= [1] @ys + [0] = [@ys] [append#2(@l', @x)] = [1] @l' + [1] >= [1] @l' + [1] = [::(@x, @l')] [length(@l)] = [0] >= [0] = [length#1(@l)] [div2(@n)] = [1] @n + [0] >= [1] @n + [0] = [div2#1(@n)] [splitAt(@n, @l)] = [1] @n + [0] >= [1] @n + [0] = [splitAt#1(@n, @l)] [zipWithOr(@l1, @l2)] = [1] @l2 + [1] >= [1] @l2 + [1] = [zipWithOr#1(@l1, @l2)] [split(@l)] = [1] @l + [0] >= [1] @l + [0] = [split#1(@l)] [div2#1(#0())] = [0] >= [0] = [#0()] [div2#1(#s(@n))] = [1] @n + [1] > [1] @n + [0] = [div2#2(@n)] [div2#2(#0())] = [0] >= [0] = [#0()] [div2#2(#s(@n))] = [1] @n + [1] > [1] @n + [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [0] >= [0] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [0] >= [0] = [#0()] [split#1(::(@x1, @xs))] = [1] @xs + [1] >= [1] @xs + [1] = [split#2(@xs, @x1)] [split#1(nil())] = [0] >= [0] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [1] @xs' + [2] > [1] @xs' + [1] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [1] > [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [1] @l1 + [1] >= [1] @l1 + [1] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [splitAt#1(#0(), @l)] = [0] >= [0] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [1] @n' + [1] >= [1] @n' + [1] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [1] @n' + [1] >= [1] @n' + [1] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [1] @n' + [1] > [0] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [1] @l1 + [1] >= [1] @l1 + [1] = [tuple#2(::(@x, @l1), @l2)] [zipWithOr#1(::(@x, @xs), @l2)] = [1] @l2 + [1] >= [1] @l2 + [1] = [zipWithOr#2(@l2, @x, @xs)] [zipWithOr#1(nil(), @l2)] = [1] @l2 + [1] > [0] = [nil()] [zipWithOr#2(::(@y, @ys), @x, @xs)] = [1] @ys + [2] >= [1] @ys + [2] = [::(or(@x, @y), zipWithOr(@xs, @ys))] [zipWithOr#2(nil(), @x, @xs)] = [1] > [0] = [nil()] [#pred(#0())] = [0] >= [0] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [0] >= [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [0] >= [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [0] >= [0] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] >= [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] >= [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [0] >= [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [0] >= [0] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] >= [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] >= [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [0] >= [0] = [c_3(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [0] >= [0] = [c_4(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [0] >= [0] = [c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l))] [bitonicMerge#3^#(@h, @direction, @l)] = [1] @h + [0] >= [1] @h + [0] = [c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l))] [div2^#(@n)] = [0] >= [0] = [c_7(div2#1^#(@n))] [length^#(@l)] = [0] >= [0] = [c_8(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] >= [0] = [c_9(length^#(@xs))] [div2#1^#(#s(@n))] = [0] >= [0] = [c_10(div2#2^#(@n))] [bitonicMerge#4^#(@s, @direction)] = [1] @s + [0] >= [1] @s + [0] = [c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s))] [splitAt^#(@n, @l)] = [0] >= [0] = [c_12(splitAt#1^#(@n, @l))] [splitAt#1^#(#s(@n'), @l)] = [0] >= [0] = [c_13(splitAt#2^#(@l, @n'))] [bitonicMerge#5^#(@hi, @direction, @s)] = [1] @s + [0] >= [1] @s + [0] = [c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s))] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0] >= [0] = [c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [0] >= [0] = [c_16(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [0] >= [0] = [c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [1] @zipWithAnd@3 + [0] >= [1] @zipWithAnd@3 + [0] = [c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [1] @l1 + [0] >= [1] @l1 + [0] = [c_19(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [0] >= [0] = [c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [zipWithOr#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_21(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [1] @xs + [1] > [1] @xs + [0] = [c_22(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [0] >= [0] = [c_23(bitonicSort#1^#(@l, @dir, @l))] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [0] >= [0] = [c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [0] >= [0] = [c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true()))] [split^#(@l)] = [0] >= [0] = [c_26(split#1^#(@l))] [split#1^#(::(@x1, @xs))] = [0] >= [0] = [c_27(split#2^#(@xs, @x1))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [0] >= [0] = [c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false()))] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [0] >= [0] = [c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2))] [div2#2^#(#s(@n))] = [0] >= [0] = [c_30(div2^#(@n))] [split#2^#(::(@x2, @xs'), @x1)] = [0] >= [0] = [c_31(split^#(@xs'))] [splitAt#2^#(::(@x, @xs), @n')] = [0] >= [0] = [c_32(splitAt^#(@n', @xs))] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [1] @xs + [0] >= [1] @xs + [0] = [c_33(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_34(zipWithOr^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , 2: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , 3: bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , 4: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , 5: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , 6: bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , 7: div2^#(@n) -> c_7(div2#1^#(@n)) , 8: length^#(@l) -> c_8(length#1^#(@l)) , 9: length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , 10: bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , 11: splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , 12: bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , 13: bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , 14: zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , 15: bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , 16: bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , 17: zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , 18: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , 19: zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , 20: zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , 21: bitonicSort^#(@l, @dir) -> c_23(bitonicSort#1^#(@l, @dir, @l)) , 22: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , 23: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , 24: split^#(@l) -> c_26(split#1^#(@l)) , 25: split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , 26: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , 27: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , 28: split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , 29: zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , 30: zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) , 31: div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , 32: splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , 33: div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , 34: splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {20}. These cover all (indirect) predecessors of dependency pairs {20,29}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_23(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , split^#(@l) -> c_26(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak DPs: { div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 28: zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) , 29: div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , 32: div2#2^#(#s(@n)) -> c_30(div2^#(@n)) } Trs: { #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicSort#1(nil(), @dir, @l) -> nil() , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1, 2, 3}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1, 2}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1, 2}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1, 2, 3}, Uargs(c_21) = {1}, Uargs(c_22) = {1}, Uargs(c_23) = {1}, Uargs(c_24) = {1, 2}, Uargs(c_25) = {1, 2}, Uargs(c_26) = {1}, Uargs(c_27) = {1}, Uargs(c_28) = {1, 2}, Uargs(c_29) = {1, 2}, Uargs(c_30) = {1}, Uargs(c_31) = {1}, Uargs(c_32) = {1}, Uargs(c_33) = {1}, Uargs(c_34) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [1] x1 + [1] x2 + [0] [#add](x1, x2) = [1] x1 + [1] x2 + [0] [and](x1, x2) = [0] [#and](x1, x2) = [1] x1 + [1] x2 + [0] [append](x1, x2) = [1] x1 + [1] x2 + [0] [append#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x2 + [1] [append#2](x1, x2) = [1] x1 + [1] [nil] = [0] [bitonicMerge](x1, x2) = [1] x1 + [1] [bitonicMerge#1](x1, x2, x3) = [1] x3 + [1] [bitonicMerge#2](x1, x2, x3) = [1] x1 + [1] x3 + [0] [#false] = [0] [bitonicMerge#10](x1, x2, x3) = [1] [tuple#2](x1, x2) = [1] x1 + [0] [#true] = [0] [length](x1) = [0] [div2](x1) = [1] x1 + [0] [bitonicMerge#3](x1, x2, x3) = [0] [splitAt](x1, x2) = [1] x1 + [0] [bitonicMerge#4](x1, x2) = [0] [bitonicMerge#6](x1) = [0] [bitonicMerge#5](x1, x2, x3) = [1] [bitonicMerge#8](x1) = [0] [bitonicMerge#7](x1, x2, x3) = [1] x1 + [0] [zipWithOr](x1, x2) = [0] [bitonicMerge#9](x1, x2) = [1] x1 + [0] [zipWithAnd](x1, x2) = [1] x2 + [0] [bitonicSort](x1, x2) = [1] x1 + [0] [bitonicSort#1](x1, x2, x3) = [1] [split](x1) = [1] x1 + [1] [bitonicSort#2](x1, x2) = [1] x1 + [1] [bitonicSort#3](x1, x2, x3, x4) = [0] [bitonicSort#4](x1, x2, x3, x4) = [0] [div2#1](x1) = [1] x1 + [0] [#0] = [0] [#s](x1) = [1] x1 + [1] [div2#2](x1) = [1] x1 + [0] [#pos](x1) = [0] [length#1](x1) = [0] [or](x1, x2) = [0] [#or](x1, x2) = [1] x1 + [1] x2 + [0] [split#1](x1) = [1] x1 + [1] [split#2](x1, x2) = [1] x1 + [1] [split#3](x1, x2, x3) = [1] x1 + [1] [splitAt#1](x1, x2) = [1] x1 + [0] [splitAt#2](x1, x2) = [1] x2 + [1] [splitAt#3](x1, x2) = [1] x1 + [1] [zipWithAnd#1](x1, x2) = [1] x2 + [0] [zipWithAnd#2](x1, x2, x3) = [1] x1 + [0] [zipWithOr#1](x1, x2) = [1] [zipWithOr#2](x1, x2, x3) = [0] [#neg](x1) = [1] x1 + [0] [#pred](x1) = [1] x1 + [1] [#succ](x1) = [1] x1 + [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [and^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [append^#](x1, x2) = [0] [append#1^#](x1, x2) = [0] [append#2^#](x1, x2) = [0] [bitonicMerge^#](x1, x2) = [0] [bitonicMerge#1^#](x1, x2, x3) = [0] [bitonicMerge#2^#](x1, x2, x3) = [0] [bitonicMerge#3^#](x1, x2, x3) = [1] x1 + [0] [div2^#](x1) = [1] x1 + [0] [length^#](x1) = [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [length#1^#](x1) = [0] [div2#1^#](x1) = [1] x1 + [0] [bitonicMerge#4^#](x1, x2) = [1] x1 + [0] [splitAt^#](x1, x2) = [0] [splitAt#1^#](x1, x2) = [0] [bitonicMerge#5^#](x1, x2, x3) = [0] [bitonicMerge#6^#](x1) = [1] x1 + [0] [zipWithOr^#](x1, x2) = [1] x1 + [0] [bitonicMerge#7^#](x1, x2, x3) = [0] [bitonicMerge#8^#](x1) = [0] [zipWithAnd^#](x1, x2) = [0] [bitonicMerge#9^#](x1, x2) = [0] [zipWithOr#1^#](x1, x2) = [1] x1 + [0] [zipWithAnd#1^#](x1, x2) = [0] [bitonicSort^#](x1, x2) = [0] [bitonicSort#1^#](x1, x2, x3) = [0] [bitonicSort#2^#](x1, x2) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [bitonicSort#3^#](x1, x2, x3, x4) = [0] [bitonicSort#4^#](x1, x2, x3, x4) = [0] [div2#2^#](x1) = [1] x1 + [0] [or^#](x1, x2) = [0] [#or^#](x1, x2) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [splitAt#2^#](x1, x2) = [0] [splitAt#3^#](x1, x2) = [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [zipWithOr#2^#](x1, x2, x3) = [1] x3 + [1] [#succ^#](x1) = [0] [#pred^#](x1) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_6](x1, x2) = [1] x1 + [1] x2 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1, x2) = [1] x1 + [1] x2 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1, x2) = [1] x1 + [1] x2 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] [c_19](x1) = [1] x1 + [0] [c_20](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_21](x1) = [1] x1 + [0] [c_22](x1) = [1] x1 + [0] [c_23](x1) = [1] x1 + [0] [c_24](x1, x2) = [1] x1 + [1] x2 + [0] [c_25](x1, x2) = [1] x1 + [1] x2 + [0] [c_26](x1) = [1] x1 + [0] [c_27](x1) = [1] x1 + [0] [c_28](x1, x2) = [1] x1 + [1] x2 + [0] [c_29](x1, x2) = [1] x1 + [1] x2 + [0] [c_30](x1) = [1] x1 + [0] [c_31](x1) = [1] x1 + [0] [c_32](x1) = [1] x1 + [0] [c_33](x1) = [1] x1 + [0] [c_34](x1) = [1] x1 + [0] This order satisfies following ordering constraints [+(@x, @y)] = [1] @x + [1] @y + [0] >= [1] @x + [1] @y + [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1] @y + [1] >= [1] @y + [1] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1] @x + [1] @y + [2] > [1] @y + [1] = [#pred(#add(#pos(#s(@x)), @y))] [append(@l, @ys)] = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [1] @xs + [1] @ys + [1] >= [1] @xs + [1] @ys + [1] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [1] @ys + [0] >= [1] @ys + [0] = [@ys] [append#2(@l', @x)] = [1] @l' + [1] >= [1] @l' + [1] = [::(@x, @l')] [length(@l)] = [0] >= [0] = [length#1(@l)] [div2(@n)] = [1] @n + [0] >= [1] @n + [0] = [div2#1(@n)] [splitAt(@n, @l)] = [1] @n + [0] >= [1] @n + [0] = [splitAt#1(@n, @l)] [zipWithAnd(@l1, @l2)] = [1] @l2 + [0] >= [1] @l2 + [0] = [zipWithAnd#1(@l1, @l2)] [split(@l)] = [1] @l + [1] >= [1] @l + [1] = [split#1(@l)] [div2#1(#0())] = [0] >= [0] = [#0()] [div2#1(#s(@n))] = [1] @n + [1] > [1] @n + [0] = [div2#2(@n)] [div2#2(#0())] = [0] >= [0] = [#0()] [div2#2(#s(@n))] = [1] @n + [1] > [1] @n + [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [0] >= [0] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [0] >= [0] = [#0()] [split#1(::(@x1, @xs))] = [1] @xs + [2] > [1] @xs + [1] = [split#2(@xs, @x1)] [split#1(nil())] = [1] > [0] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [1] @xs' + [2] >= [1] @xs' + [2] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [1] > [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [1] @l1 + [1] >= [1] @l1 + [1] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [splitAt#1(#0(), @l)] = [0] >= [0] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [1] @n' + [1] >= [1] @n' + [1] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [1] @n' + [1] >= [1] @n' + [1] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [1] @n' + [1] > [0] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [1] @l1 + [1] >= [1] @l1 + [1] = [tuple#2(::(@x, @l1), @l2)] [zipWithAnd#1(::(@x, @xs), @l2)] = [1] @l2 + [0] >= [1] @l2 + [0] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [1] @l2 + [0] >= [0] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [1] @ys + [1] >= [1] @ys + [1] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [0] >= [0] = [nil()] [#pred(#0())] = [1] >= [1] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [1] > [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [1] > [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [1] @x + [2] >= [1] @x + [2] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] >= [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] >= [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [1] > [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [1] @x + [2] > [1] @x + [1] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] >= [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] >= [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [0] >= [0] = [c_3(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [0] >= [0] = [c_4(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [0] >= [0] = [c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l))] [bitonicMerge#3^#(@h, @direction, @l)] = [1] @h + [0] >= [1] @h + [0] = [c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l))] [div2^#(@n)] = [1] @n + [0] >= [1] @n + [0] = [c_7(div2#1^#(@n))] [length^#(@l)] = [0] >= [0] = [c_8(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] >= [0] = [c_9(length^#(@xs))] [div2#1^#(#s(@n))] = [1] @n + [1] > [1] @n + [0] = [c_10(div2#2^#(@n))] [bitonicMerge#4^#(@s, @direction)] = [1] @s + [0] >= [1] @s + [0] = [c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s))] [splitAt^#(@n, @l)] = [0] >= [0] = [c_12(splitAt#1^#(@n, @l))] [splitAt#1^#(#s(@n'), @l)] = [0] >= [0] = [c_13(splitAt#2^#(@l, @n'))] [bitonicMerge#5^#(@hi, @direction, @s)] = [0] >= [0] = [c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s))] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [1] @zipWithOr@1 + [0] >= [1] @zipWithOr@1 + [0] = [c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [1] @l1 + [0] >= [1] @l1 + [0] = [c_16(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [0] >= [0] = [c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0] >= [0] = [c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [0] >= [0] = [c_19(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [0] >= [0] = [c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [zipWithOr#1^#(::(@x, @xs), @l2)] = [1] @xs + [1] >= [1] @xs + [1] = [c_21(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_22(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [0] >= [0] = [c_23(bitonicSort#1^#(@l, @dir, @l))] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [0] >= [0] = [c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [0] >= [0] = [c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true()))] [split^#(@l)] = [0] >= [0] = [c_26(split#1^#(@l))] [split#1^#(::(@x1, @xs))] = [0] >= [0] = [c_27(split#2^#(@xs, @x1))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [0] >= [0] = [c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false()))] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [0] >= [0] = [c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2))] [div2#2^#(#s(@n))] = [1] @n + [1] > [1] @n + [0] = [c_30(div2^#(@n))] [split#2^#(::(@x2, @xs'), @x1)] = [0] >= [0] = [c_31(split^#(@xs'))] [splitAt#2^#(::(@x, @xs), @n')] = [0] >= [0] = [c_32(splitAt^#(@n', @xs))] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_33(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [1] @xs + [1] > [1] @xs + [0] = [c_34(zipWithOr^#(@xs, @ys))] The strictly oriented rules are moved into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_23(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , split^#(@l) -> c_26(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) } Weak DPs: { div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 19: zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , 28: div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , 31: div2#2^#(#s(@n)) -> c_30(div2^#(@n)) } Trs: { #and(#false(), #false()) -> #false() , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1, 2, 3}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1, 2}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1, 2}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1, 2, 3}, Uargs(c_21) = {1}, Uargs(c_22) = {1}, Uargs(c_23) = {1}, Uargs(c_24) = {1, 2}, Uargs(c_25) = {1, 2}, Uargs(c_26) = {1}, Uargs(c_27) = {1}, Uargs(c_28) = {1, 2}, Uargs(c_29) = {1, 2}, Uargs(c_30) = {1}, Uargs(c_31) = {1}, Uargs(c_32) = {1}, Uargs(c_33) = {1}, Uargs(c_34) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [1] x2 + [0] [#add](x1, x2) = [1] x2 + [0] [and](x1, x2) = [0] [#and](x1, x2) = [1] x1 + [1] x2 + [0] [append](x1, x2) = [1] x1 + [1] x2 + [0] [append#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x2 + [1] [append#2](x1, x2) = [1] x1 + [1] [nil] = [0] [bitonicMerge](x1, x2) = [1] x1 + [0] [bitonicMerge#1](x1, x2, x3) = [1] x3 + [1] [bitonicMerge#2](x1, x2, x3) = [1] x1 + [1] x3 + [0] [#false] = [1] [bitonicMerge#10](x1, x2, x3) = [1] [tuple#2](x1, x2) = [1] x1 + [0] [#true] = [0] [length](x1) = [0] [div2](x1) = [1] x1 + [0] [bitonicMerge#3](x1, x2, x3) = [0] [splitAt](x1, x2) = [1] x1 + [0] [bitonicMerge#4](x1, x2) = [0] [bitonicMerge#6](x1) = [0] [bitonicMerge#5](x1, x2, x3) = [1] [bitonicMerge#8](x1) = [0] [bitonicMerge#7](x1, x2, x3) = [0] [zipWithOr](x1, x2) = [0] [bitonicMerge#9](x1, x2) = [1] x1 + [1] [zipWithAnd](x1, x2) = [1] [bitonicSort](x1, x2) = [0] [bitonicSort#1](x1, x2, x3) = [1] [split](x1) = [0] [bitonicSort#2](x1, x2) = [0] [bitonicSort#3](x1, x2, x3, x4) = [0] [bitonicSort#4](x1, x2, x3, x4) = [0] [div2#1](x1) = [1] x1 + [0] [#0] = [0] [#s](x1) = [1] x1 + [1] [div2#2](x1) = [1] x1 + [1] [#pos](x1) = [0] [length#1](x1) = [0] [or](x1, x2) = [0] [#or](x1, x2) = [1] x1 + [1] x2 + [0] [split#1](x1) = [0] [split#2](x1, x2) = [0] [split#3](x1, x2, x3) = [1] x1 + [1] [splitAt#1](x1, x2) = [1] x1 + [0] [splitAt#2](x1, x2) = [1] x2 + [1] [splitAt#3](x1, x2) = [1] x1 + [1] [zipWithAnd#1](x1, x2) = [1] [zipWithAnd#2](x1, x2, x3) = [1] [zipWithOr#1](x1, x2) = [1] [zipWithOr#2](x1, x2, x3) = [0] [#neg](x1) = [0] [#pred](x1) = [1] x1 + [0] [#succ](x1) = [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [and^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [append^#](x1, x2) = [0] [append#1^#](x1, x2) = [0] [append#2^#](x1, x2) = [0] [bitonicMerge^#](x1, x2) = [0] [bitonicMerge#1^#](x1, x2, x3) = [0] [bitonicMerge#2^#](x1, x2, x3) = [0] [bitonicMerge#3^#](x1, x2, x3) = [1] x1 + [0] [div2^#](x1) = [1] x1 + [0] [length^#](x1) = [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [length#1^#](x1) = [0] [div2#1^#](x1) = [1] x1 + [0] [bitonicMerge#4^#](x1, x2) = [1] x1 + [0] [splitAt^#](x1, x2) = [0] [splitAt#1^#](x1, x2) = [0] [bitonicMerge#5^#](x1, x2, x3) = [0] [bitonicMerge#6^#](x1) = [1] x1 + [0] [zipWithOr^#](x1, x2) = [1] x1 + [0] [bitonicMerge#7^#](x1, x2, x3) = [0] [bitonicMerge#8^#](x1) = [0] [zipWithAnd^#](x1, x2) = [0] [bitonicMerge#9^#](x1, x2) = [0] [zipWithOr#1^#](x1, x2) = [1] x1 + [0] [zipWithAnd#1^#](x1, x2) = [0] [bitonicSort^#](x1, x2) = [0] [bitonicSort#1^#](x1, x2, x3) = [0] [bitonicSort#2^#](x1, x2) = [0] [split^#](x1) = [0] [split#1^#](x1) = [0] [bitonicSort#3^#](x1, x2, x3, x4) = [0] [bitonicSort#4^#](x1, x2, x3, x4) = [0] [div2#2^#](x1) = [1] x1 + [0] [or^#](x1, x2) = [0] [#or^#](x1, x2) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [splitAt#2^#](x1, x2) = [0] [splitAt#3^#](x1, x2) = [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [zipWithOr#2^#](x1, x2, x3) = [1] x3 + [0] [#succ^#](x1) = [0] [#pred^#](x1) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_6](x1, x2) = [1] x1 + [1] x2 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1, x2) = [1] x1 + [1] x2 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1, x2) = [1] x1 + [1] x2 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] [c_19](x1) = [1] x1 + [0] [c_20](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_21](x1) = [1] x1 + [0] [c_22](x1) = [1] x1 + [0] [c_23](x1) = [1] x1 + [0] [c_24](x1, x2) = [1] x1 + [1] x2 + [0] [c_25](x1, x2) = [1] x1 + [1] x2 + [0] [c_26](x1) = [1] x1 + [0] [c_27](x1) = [1] x1 + [0] [c_28](x1, x2) = [1] x1 + [1] x2 + [0] [c_29](x1, x2) = [1] x1 + [1] x2 + [0] [c_30](x1) = [1] x1 + [0] [c_31](x1) = [1] x1 + [0] [c_32](x1) = [1] x1 + [0] [c_33](x1) = [1] x1 + [0] [c_34](x1) = [1] x1 + [0] This order satisfies following ordering constraints [+(@x, @y)] = [1] @y + [0] >= [1] @y + [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1] @y + [0] >= [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1] @y + [0] >= [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1] @y + [0] >= [1] @y + [0] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1] @y + [0] >= [1] @y + [0] = [#pred(#add(#pos(#s(@x)), @y))] [append(@l, @ys)] = [1] @l + [1] @ys + [0] >= [1] @l + [1] @ys + [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [1] @xs + [1] @ys + [1] >= [1] @xs + [1] @ys + [1] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [1] @ys + [0] >= [1] @ys + [0] = [@ys] [append#2(@l', @x)] = [1] @l' + [1] >= [1] @l' + [1] = [::(@x, @l')] [length(@l)] = [0] >= [0] = [length#1(@l)] [div2(@n)] = [1] @n + [0] >= [1] @n + [0] = [div2#1(@n)] [splitAt(@n, @l)] = [1] @n + [0] >= [1] @n + [0] = [splitAt#1(@n, @l)] [div2#1(#0())] = [0] >= [0] = [#0()] [div2#1(#s(@n))] = [1] @n + [1] >= [1] @n + [1] = [div2#2(@n)] [div2#2(#0())] = [1] > [0] = [#0()] [div2#2(#s(@n))] = [1] @n + [2] > [1] @n + [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [0] >= [0] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [0] >= [0] = [#0()] [splitAt#1(#0(), @l)] = [0] >= [0] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [1] @n' + [1] >= [1] @n' + [1] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [1] @n' + [1] >= [1] @n' + [1] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [1] @n' + [1] > [0] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [1] @l1 + [1] >= [1] @l1 + [1] = [tuple#2(::(@x, @l1), @l2)] [#pred(#0())] = [0] >= [0] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [0] >= [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [0] >= [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [0] >= [0] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] >= [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] >= [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [0] >= [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [0] >= [0] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] >= [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] >= [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [0] >= [0] = [c_3(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [0] >= [0] = [c_4(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [0] >= [0] = [c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l))] [bitonicMerge#3^#(@h, @direction, @l)] = [1] @h + [0] >= [1] @h + [0] = [c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l))] [div2^#(@n)] = [1] @n + [0] >= [1] @n + [0] = [c_7(div2#1^#(@n))] [length^#(@l)] = [0] >= [0] = [c_8(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] >= [0] = [c_9(length^#(@xs))] [div2#1^#(#s(@n))] = [1] @n + [1] > [1] @n + [0] = [c_10(div2#2^#(@n))] [bitonicMerge#4^#(@s, @direction)] = [1] @s + [0] >= [1] @s + [0] = [c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s))] [splitAt^#(@n, @l)] = [0] >= [0] = [c_12(splitAt#1^#(@n, @l))] [splitAt#1^#(#s(@n'), @l)] = [0] >= [0] = [c_13(splitAt#2^#(@l, @n'))] [bitonicMerge#5^#(@hi, @direction, @s)] = [0] >= [0] = [c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s))] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [1] @zipWithOr@1 + [0] >= [1] @zipWithOr@1 + [0] = [c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [1] @l1 + [0] >= [1] @l1 + [0] = [c_16(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [0] >= [0] = [c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0] >= [0] = [c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [0] >= [0] = [c_19(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [0] >= [0] = [c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [zipWithOr#1^#(::(@x, @xs), @l2)] = [1] @xs + [1] > [1] @xs + [0] = [c_21(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_22(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [0] >= [0] = [c_23(bitonicSort#1^#(@l, @dir, @l))] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [0] >= [0] = [c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [0] >= [0] = [c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true()))] [split^#(@l)] = [0] >= [0] = [c_26(split#1^#(@l))] [split#1^#(::(@x1, @xs))] = [0] >= [0] = [c_27(split#2^#(@xs, @x1))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [0] >= [0] = [c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false()))] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [0] >= [0] = [c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2))] [div2#2^#(#s(@n))] = [1] @n + [1] > [1] @n + [0] = [c_30(div2^#(@n))] [split#2^#(::(@x2, @xs'), @x1)] = [0] >= [0] = [c_31(split^#(@xs'))] [splitAt#2^#(::(@x, @xs), @n')] = [0] >= [0] = [c_32(splitAt^#(@n', @xs))] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_33(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [1] @xs + [0] >= [1] @xs + [0] = [c_34(zipWithOr^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , 2: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , 3: bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , 4: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , 5: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , 6: bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , 7: div2^#(@n) -> c_7(div2#1^#(@n)) , 8: length^#(@l) -> c_8(length#1^#(@l)) , 9: length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , 10: bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , 11: splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , 12: bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , 13: bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , 14: zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , 15: bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , 16: bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , 17: zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , 18: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , 19: zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , 20: bitonicSort^#(@l, @dir) -> c_23(bitonicSort#1^#(@l, @dir, @l)) , 21: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , 22: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , 23: split^#(@l) -> c_26(split#1^#(@l)) , 24: split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , 25: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , 26: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , 27: split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , 28: div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , 29: splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , 30: zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , 31: div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , 32: splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , 33: zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , 34: zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {19,28,31}. These cover all (indirect) predecessors of dependency pairs {19,28,31,34}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^4)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , bitonicSort^#(@l, @dir) -> c_23(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , split^#(@l) -> c_26(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) } Weak DPs: { div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^4)) We decompose the input problem according to the dependency graph into the upper component { bitonicSort^#(@l, @dir) -> c_23(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) } and lower component { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , split^#(@l) -> c_26(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Further, following extension rules are added to the lower component. { bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> split^#(@l) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) } TcT solves the upper component with certificate YES(O(1),O(n^2)). Sub-proof: ---------- We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { bitonicSort^#(@l, @dir) -> c_23(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_25(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_24(bitonicSort#2^#(split(@l), @dir), split^#(@l)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_28(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2), bitonicSort^#(@l2, #false())) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { bitonicSort^#(@l, @dir) -> c_1(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_2(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_3(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_4(bitonicSort^#(@l2, #false())) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 4: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_4(bitonicSort^#(@l2, #false())) } Trs: { split#2(nil(), @x1) -> tuple#2(nil(), nil()) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1, 2}, Uargs(c_4) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [0] [0] [#add](x1, x2) = [0] [0] [and](x1, x2) = [0] [0] [#and](x1, x2) = [0] [0] [append](x1, x2) = [0 0] x2 + [0] [0 1] [0] [append#1](x1, x2) = [2 0] x2 + [0] [2 2] [0] [::](x1, x2) = [1 2] x1 + [1 2] x2 + [1] [0 0] [0 1] [1] [append#2](x1, x2) = [2 0] x2 + [2] [0 0] [0] [nil] = [0] [0] [bitonicMerge](x1, x2) = [0] [0] [bitonicMerge#1](x1, x2, x3) = [2 0] x2 + [0] [2 2] [0] [bitonicMerge#2](x1, x2, x3) = [2 0] x3 + [0] [2 2] [0] [#false] = [0] [1] [bitonicMerge#10](x1, x2, x3) = [0] [0] [tuple#2](x1, x2) = [1 1] x1 + [1 1] x2 + [1] [0 1] [0 1] [2] [#true] = [1] [0] [length](x1) = [0] [0] [div2](x1) = [0] [0] [bitonicMerge#3](x1, x2, x3) = [2 0] x2 + [0] [2 2] [0] [splitAt](x1, x2) = [0] [0] [bitonicMerge#4](x1, x2) = [0 0] x2 + [0] [1 0] [0] [bitonicMerge#6](x1) = [0] [0] [bitonicMerge#5](x1, x2, x3) = [2 0] x2 + [0] [0 0] [0] [bitonicMerge#8](x1) = [0] [0] [bitonicMerge#7](x1, x2, x3) = [2 0] x2 + [0 0] x3 + [0] [2 2] [2 2] [0] [zipWithOr](x1, x2) = [0] [0] [bitonicMerge#9](x1, x2) = [0] [0] [zipWithAnd](x1, x2) = [0] [0] [bitonicSort](x1, x2) = [1 0] x1 + [0] [1 0] [0] [bitonicSort#1](x1, x2, x3) = [2 0] x2 + [0] [2 2] [0] [split](x1) = [1 0] x1 + [1] [0 2] [2] [bitonicSort#2](x1, x2) = [2 0] x2 + [0] [2 0] [0] [bitonicSort#3](x1, x2, x3, x4) = [2 0] x2 + [2 0] x4 + [0] [2 2] [2 2] [0] [bitonicSort#4](x1, x2, x3, x4) = [0 0] x2 + [2 0] x3 + [0] [1 0] [2 2] [0] [div2#1](x1) = [0] [0] [#0] = [0] [0] [#s](x1) = [0] [0] [div2#2](x1) = [0] [0] [#pos](x1) = [1 0] x1 + [0] [0 0] [0] [length#1](x1) = [0] [0] [or](x1, x2) = [0] [0] [#or](x1, x2) = [0] [0] [split#1](x1) = [1 0] x1 + [1] [0 2] [2] [split#2](x1, x2) = [1 2] x1 + [1 2] x2 + [2] [0 2] [0 0] [2] [split#3](x1, x2, x3) = [1 2] x1 + [1 2] x2 + [1 2] x3 + [0] [0 1] [0 0] [0 0] [2] [splitAt#1](x1, x2) = [2 0] x2 + [0] [2 2] [0] [splitAt#2](x1, x2) = [2 0] x2 + [0] [2 2] [0] [splitAt#3](x1, x2) = [0] [0] [zipWithAnd#1](x1, x2) = [2 0] x2 + [0] [2 2] [0] [zipWithAnd#2](x1, x2, x3) = [2 0] x2 + [2 0] x3 + [0] [0 0] [2 2] [0] [zipWithOr#1](x1, x2) = [2 0] x2 + [0] [2 2] [0] [zipWithOr#2](x1, x2, x3) = [0 0] x2 + [2 0] x3 + [0] [2 2] [2 2] [0] [#neg](x1) = [0 0] x1 + [0] [0 1] [0] [#pred](x1) = [0] [0] [#succ](x1) = [0] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [and^#](x1, x2) = [0] [0] [#and^#](x1, x2) = [0] [0] [append^#](x1, x2) = [0] [0] [append#1^#](x1, x2) = [0] [0] [append#2^#](x1, x2) = [0] [0] [bitonicMerge^#](x1, x2) = [0] [0] [bitonicMerge#1^#](x1, x2, x3) = [0] [0] [bitonicMerge#2^#](x1, x2, x3) = [0] [0] [bitonicMerge#3^#](x1, x2, x3) = [0] [0] [div2^#](x1) = [0] [0] [length^#](x1) = [0] [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [0] [length#1^#](x1) = [0] [0] [div2#1^#](x1) = [0] [0] [bitonicMerge#4^#](x1, x2) = [0] [0] [splitAt^#](x1, x2) = [0] [0] [splitAt#1^#](x1, x2) = [0] [0] [bitonicMerge#5^#](x1, x2, x3) = [0] [0] [bitonicMerge#6^#](x1) = [0] [0] [zipWithOr^#](x1, x2) = [0] [0] [bitonicMerge#7^#](x1, x2, x3) = [0] [0] [bitonicMerge#8^#](x1) = [0] [0] [zipWithAnd^#](x1, x2) = [0] [0] [bitonicMerge#9^#](x1, x2) = [0] [0] [zipWithOr#1^#](x1, x2) = [0] [0] [zipWithAnd#1^#](x1, x2) = [0] [0] [bitonicSort^#](x1, x2) = [2 2] x1 + [0 0] x2 + [0] [0 0] [0 1] [0] [bitonicSort#1^#](x1, x2, x3) = [0 2] x1 + [2 0] x3 + [0] [0 0] [0 0] [0] [bitonicSort#2^#](x1, x2) = [2 0] x1 + [0] [0 0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [bitonicSort#3^#](x1, x2, x3, x4) = [2 2] x4 + [2] [0 1] [0] [bitonicSort#4^#](x1, x2, x3, x4) = [0] [0] [div2#2^#](x1) = [0] [0] [or^#](x1, x2) = [0] [0] [#or^#](x1, x2) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [splitAt#2^#](x1, x2) = [0] [0] [splitAt#3^#](x1, x2) = [0] [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [0] [zipWithOr#2^#](x1, x2, x3) = [0] [0] [#succ^#](x1) = [0] [0] [#pred^#](x1) = [0] [0] [c_23](x1) = [0] [0] [c_24](x1, x2) = [0] [0] [c_25](x1, x2) = [0] [0] [c_28](x1, x2) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [0] [c_2](x1) = [1 1] x1 + [0] [0 0] [0] [c_3](x1, x2) = [1 0] x1 + [1 1] x2 + [0] [0 0] [0 0] [0] [c_4](x1) = [1 1] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [split(@l)] = [1 0] @l + [1] [0 2] [2] >= [1 0] @l + [1] [0 2] [2] = [split#1(@l)] [split#1(::(@x1, @xs))] = [1 2] @x1 + [1 2] @xs + [2] [0 0] [0 2] [4] >= [1 2] @x1 + [1 2] @xs + [2] [0 0] [0 2] [2] = [split#2(@xs, @x1)] [split#1(nil())] = [1] [2] >= [1] [2] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [1 2] @x1 + [1 2] @x2 + [1 4] @xs' + [5] [0 0] [0 0] [0 2] [4] >= [1 2] @x1 + [1 2] @x2 + [1 4] @xs' + [5] [0 0] [0 0] [0 2] [4] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [1 2] @x1 + [2] [0 0] [2] > [1] [2] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [1 3] @l1 + [1 3] @l2 + [1 2] @x1 + [1 2] @x2 + [5] [0 1] [0 1] [0 0] [0 0] [4] >= [1 3] @l1 + [1 3] @l2 + [1 2] @x1 + [1 2] @x2 + [5] [0 1] [0 1] [0 0] [0 0] [4] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [bitonicSort^#(@l, @dir)] = [0 0] @dir + [2 2] @l + [0] [0 1] [0 0] [0] >= [2 2] @l + [0] [0 0] [0] = [c_1(bitonicSort#1^#(@l, @dir, @l))] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [2 0] @l + [0 2] @xs + [2] [0 0] [0 0] [0] >= [2 0] @l + [2] [0 0] [0] = [c_2(bitonicSort#2^#(split(@l), @dir))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [2 2] @l1 + [2 2] @l2 + [2] [0 0] [0 0] [0] >= [2 2] @l1 + [2 2] @l2 + [2] [0 0] [0 0] [0] = [c_3(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true()))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [2 2] @l2 + [2] [0 1] [0] > [2 2] @l2 + [1] [0 0] [0] = [c_4(bitonicSort^#(@l2, #false()))] The strictly oriented rules are moved into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { bitonicSort^#(@l, @dir) -> c_1(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_2(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_3(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) } Weak DPs: { bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_4(bitonicSort^#(@l2, #false())) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 2: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_2(bitonicSort#2^#(split(@l), @dir)) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1, 2}, Uargs(c_4) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [0] [0] [#add](x1, x2) = [0] [0] [and](x1, x2) = [0] [0] [#and](x1, x2) = [0] [0] [append](x1, x2) = [0 2] x2 + [0] [0 1] [0] [append#1](x1, x2) = [2 2] x2 + [0] [2 2] [0] [::](x1, x2) = [1 2] x2 + [0] [0 0] [1] [append#2](x1, x2) = [0 2] x1 + [2 0] x2 + [0] [0 0] [0 0] [0] [nil] = [0] [0] [bitonicMerge](x1, x2) = [0] [0] [bitonicMerge#1](x1, x2, x3) = [0] [0] [bitonicMerge#2](x1, x2, x3) = [2 0] x2 + [2 0] x3 + [0] [2 2] [0 2] [0] [#false] = [0] [0] [bitonicMerge#10](x1, x2, x3) = [0] [0] [tuple#2](x1, x2) = [1 1] x1 + [1 1] x2 + [0] [0 1] [0 1] [0] [#true] = [1] [1] [length](x1) = [0] [0] [div2](x1) = [0] [0] [bitonicMerge#3](x1, x2, x3) = [2 0] x2 + [0] [2 0] [0] [splitAt](x1, x2) = [0] [0] [bitonicMerge#4](x1, x2) = [2 0] x2 + [0] [2 0] [0] [bitonicMerge#6](x1) = [0] [0] [bitonicMerge#5](x1, x2, x3) = [0] [0] [bitonicMerge#8](x1) = [0] [0] [bitonicMerge#7](x1, x2, x3) = [0] [0] [zipWithOr](x1, x2) = [0] [0] [bitonicMerge#9](x1, x2) = [0] [0] [zipWithAnd](x1, x2) = [0] [0] [bitonicSort](x1, x2) = [0 0] x1 + [1 1] x2 + [0] [1 0] [0 1] [0] [bitonicSort#1](x1, x2, x3) = [2 0] x2 + [0] [2 2] [0] [split](x1) = [1 0] x1 + [0] [0 2] [0] [bitonicSort#2](x1, x2) = [0] [0] [bitonicSort#3](x1, x2, x3, x4) = [2 0] x2 + [0 0] x4 + [0] [2 0] [2 2] [0] [bitonicSort#4](x1, x2, x3, x4) = [2 0] x3 + [0] [0 0] [0] [div2#1](x1) = [0] [0] [#0] = [0] [0] [#s](x1) = [1 0] x1 + [0] [0 1] [0] [div2#2](x1) = [0] [0] [#pos](x1) = [0] [0] [length#1](x1) = [0] [0] [or](x1, x2) = [0] [0] [#or](x1, x2) = [0] [0] [split#1](x1) = [1 0] x1 + [0] [0 2] [0] [split#2](x1, x2) = [1 2] x1 + [0] [0 0] [2] [split#3](x1, x2, x3) = [1 1] x1 + [2] [0 0] [2] [splitAt#1](x1, x2) = [2 0] x2 + [0] [2 2] [0] [splitAt#2](x1, x2) = [2 0] x2 + [0] [0 2] [0] [splitAt#3](x1, x2) = [0] [0] [zipWithAnd#1](x1, x2) = [2 0] x2 + [0] [2 2] [0] [zipWithAnd#2](x1, x2, x3) = [2 0] x2 + [0 0] x3 + [0] [2 2] [2 0] [0] [zipWithOr#1](x1, x2) = [2 0] x2 + [0] [2 2] [0] [zipWithOr#2](x1, x2, x3) = [2 0] x2 + [0 0] x3 + [0] [2 2] [2 0] [0] [#neg](x1) = [0] [0] [#pred](x1) = [0] [0] [#succ](x1) = [0] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [and^#](x1, x2) = [0] [0] [#and^#](x1, x2) = [0] [0] [append^#](x1, x2) = [0] [0] [append#1^#](x1, x2) = [0] [0] [append#2^#](x1, x2) = [0] [0] [bitonicMerge^#](x1, x2) = [0] [0] [bitonicMerge#1^#](x1, x2, x3) = [0] [0] [bitonicMerge#2^#](x1, x2, x3) = [0] [0] [bitonicMerge#3^#](x1, x2, x3) = [0] [0] [div2^#](x1) = [0] [0] [length^#](x1) = [0] [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [0] [length#1^#](x1) = [0] [0] [div2#1^#](x1) = [0] [0] [bitonicMerge#4^#](x1, x2) = [0] [0] [splitAt^#](x1, x2) = [0] [0] [splitAt#1^#](x1, x2) = [0] [0] [bitonicMerge#5^#](x1, x2, x3) = [0] [0] [bitonicMerge#6^#](x1) = [0] [0] [zipWithOr^#](x1, x2) = [0] [0] [bitonicMerge#7^#](x1, x2, x3) = [0] [0] [bitonicMerge#8^#](x1) = [0] [0] [zipWithAnd^#](x1, x2) = [0] [0] [bitonicMerge#9^#](x1, x2) = [0] [0] [zipWithOr#1^#](x1, x2) = [0] [0] [zipWithAnd#1^#](x1, x2) = [0] [0] [bitonicSort^#](x1, x2) = [2 1] x1 + [0] [0 0] [0] [bitonicSort#1^#](x1, x2, x3) = [0 1] x1 + [2 0] x3 + [0] [0 0] [0 0] [0] [bitonicSort#2^#](x1, x2) = [2 0] x1 + [0] [0 0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [bitonicSort#3^#](x1, x2, x3, x4) = [2 1] x4 + [0] [0 0] [0] [bitonicSort#4^#](x1, x2, x3, x4) = [0] [0] [div2#2^#](x1) = [0] [0] [or^#](x1, x2) = [0] [0] [#or^#](x1, x2) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [splitAt#2^#](x1, x2) = [0] [0] [splitAt#3^#](x1, x2) = [0] [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [0] [zipWithOr#2^#](x1, x2, x3) = [0] [0] [#succ^#](x1) = [0] [0] [#pred^#](x1) = [0] [0] [c_23](x1) = [0] [0] [c_24](x1, x2) = [0] [0] [c_25](x1, x2) = [0] [0] [c_28](x1, x2) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 1] x1 + [0] [0 0] [0] [c_2](x1) = [1 1] x1 + [0] [0 0] [0] [c_3](x1, x2) = [1 1] x1 + [1 1] x2 + [0] [0 0] [0 0] [0] [c_4](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [split(@l)] = [1 0] @l + [0] [0 2] [0] >= [1 0] @l + [0] [0 2] [0] = [split#1(@l)] [split#1(::(@x1, @xs))] = [1 2] @xs + [0] [0 0] [2] >= [1 2] @xs + [0] [0 0] [2] = [split#2(@xs, @x1)] [split#1(nil())] = [0] [0] >= [0] [0] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [1 2] @xs' + [2] [0 0] [2] >= [1 2] @xs' + [2] [0 0] [2] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [0] [2] >= [0] [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [1 2] @l1 + [1 2] @l2 + [2] [0 0] [0 0] [2] >= [1 2] @l1 + [1 2] @l2 + [2] [0 0] [0 0] [2] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [bitonicSort^#(@l, @dir)] = [2 1] @l + [0] [0 0] [0] >= [2 1] @l + [0] [0 0] [0] = [c_1(bitonicSort#1^#(@l, @dir, @l))] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [2 0] @l + [1] [0 0] [0] > [2 0] @l + [0] [0 0] [0] = [c_2(bitonicSort#2^#(split(@l), @dir))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [2 2] @l1 + [2 2] @l2 + [0] [0 0] [0 0] [0] >= [2 1] @l1 + [2 1] @l2 + [0] [0 0] [0 0] [0] = [c_3(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true()))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [2 1] @l2 + [0] [0 0] [0] >= [2 1] @l2 + [0] [0 0] [0] = [c_4(bitonicSort^#(@l2, #false()))] Consider the set of all dependency pairs DPs: { 1: bitonicSort^#(@l, @dir) -> c_1(bitonicSort#1^#(@l, @dir, @l)) , 2: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_2(bitonicSort#2^#(split(@l), @dir)) , 3: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_3(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , 4: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_4(bitonicSort^#(@l2, #false())) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^2)) on application of dependency pairs {2}. These cover all (indirect) predecessors of dependency pairs {1,2,3,4}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { bitonicSort^#(@l, @dir) -> c_1(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_2(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_3(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_4(bitonicSort^#(@l2, #false())) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { bitonicSort^#(@l, @dir) -> c_1(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_2(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_3(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2), bitonicSort^#(@l1, #true())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_4(bitonicSort^#(@l2, #false())) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded We return to the main proof. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , split^#(@l) -> c_26(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) } Weak DPs: { div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> split^#(@l) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 20: split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , 21: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , 22: split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , 24: splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , 35: splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) } Trs: { #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , or(@x, @y) -> #or(@x, @y) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1, 2, 3}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1, 2}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1, 2}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1, 2, 3}, Uargs(c_21) = {1}, Uargs(c_22) = {1}, Uargs(c_26) = {1}, Uargs(c_27) = {1}, Uargs(c_29) = {1, 2}, Uargs(c_30) = {1}, Uargs(c_31) = {1}, Uargs(c_32) = {1}, Uargs(c_33) = {1}, Uargs(c_34) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [2] x1 + [1] x2 + [0] [#add](x1, x2) = [2] x1 + [1] x2 + [0] [and](x1, x2) = [2] x1 + [2] x2 + [2] [#and](x1, x2) = [0] [append](x1, x2) = [2] x1 + [1] x2 + [0] [append#1](x1, x2) = [2] x1 + [1] x2 + [0] [::](x1, x2) = [1] x2 + [1] [append#2](x1, x2) = [1] x1 + [2] [nil] = [0] [bitonicMerge](x1, x2) = [0] [bitonicMerge#1](x1, x2, x3) = [2] x2 + [0] [bitonicMerge#2](x1, x2, x3) = [2] x2 + [1] x3 + [0] [#false] = [2] [bitonicMerge#10](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [tuple#2](x1, x2) = [1] x1 + [1] x2 + [1] [#true] = [1] [length](x1) = [0] [div2](x1) = [2] x1 + [0] [bitonicMerge#3](x1, x2, x3) = [0] [splitAt](x1, x2) = [1] x1 + [1] x2 + [1] [bitonicMerge#4](x1, x2) = [2] x2 + [0] [bitonicMerge#6](x1) = [1] x1 + [0] [bitonicMerge#5](x1, x2, x3) = [2] x2 + [0] [bitonicMerge#8](x1) = [1] x1 + [0] [bitonicMerge#7](x1, x2, x3) = [0] [zipWithOr](x1, x2) = [1] x1 + [1] x2 + [1] [bitonicMerge#9](x1, x2) = [0] [zipWithAnd](x1, x2) = [1] x1 + [1] x2 + [1] [bitonicSort](x1, x2) = [1] [bitonicSort#1](x1, x2, x3) = [2] x2 + [0] [split](x1) = [1] x1 + [1] [bitonicSort#2](x1, x2) = [0] [bitonicSort#3](x1, x2, x3, x4) = [2] x2 + [0] [bitonicSort#4](x1, x2, x3, x4) = [2] x2 + [0] [div2#1](x1) = [2] x1 + [0] [#0] = [0] [#s](x1) = [1] x1 + [2] [div2#2](x1) = [2] x1 + [2] [#pos](x1) = [0] [length#1](x1) = [0] [or](x1, x2) = [2] x1 + [2] x2 + [2] [#or](x1, x2) = [0] [split#1](x1) = [1] x1 + [1] [split#2](x1, x2) = [1] x1 + [2] [split#3](x1, x2, x3) = [1] x1 + [2] [splitAt#1](x1, x2) = [1] x1 + [1] x2 + [1] [splitAt#2](x1, x2) = [1] x1 + [1] x2 + [2] [splitAt#3](x1, x2) = [1] x1 + [2] [zipWithAnd#1](x1, x2) = [1] x1 + [1] x2 + [1] [zipWithAnd#2](x1, x2, x3) = [1] x1 + [1] x3 + [2] [zipWithOr#1](x1, x2) = [1] x1 + [1] x2 + [1] [zipWithOr#2](x1, x2, x3) = [1] x1 + [1] x3 + [2] [#neg](x1) = [2] [#pred](x1) = [1] x1 + [2] [#succ](x1) = [1] x1 + [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [and^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [append^#](x1, x2) = [0] [append#1^#](x1, x2) = [0] [append#2^#](x1, x2) = [0] [bitonicMerge^#](x1, x2) = [0] [bitonicMerge#1^#](x1, x2, x3) = [0] [bitonicMerge#2^#](x1, x2, x3) = [0] [bitonicMerge#3^#](x1, x2, x3) = [2] x1 + [0] [div2^#](x1) = [0] [length^#](x1) = [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [length#1^#](x1) = [0] [div2#1^#](x1) = [0] [bitonicMerge#4^#](x1, x2) = [0] [splitAt^#](x1, x2) = [1] x1 + [0] [splitAt#1^#](x1, x2) = [1] x1 + [0] [bitonicMerge#5^#](x1, x2, x3) = [0] [bitonicMerge#6^#](x1) = [0] [zipWithOr^#](x1, x2) = [0] [bitonicMerge#7^#](x1, x2, x3) = [0] [bitonicMerge#8^#](x1) = [0] [zipWithAnd^#](x1, x2) = [0] [bitonicMerge#9^#](x1, x2) = [0] [zipWithOr#1^#](x1, x2) = [0] [zipWithAnd#1^#](x1, x2) = [0] [bitonicSort^#](x1, x2) = [2] x1 + [2] [bitonicSort#1^#](x1, x2, x3) = [2] x3 + [2] [bitonicSort#2^#](x1, x2) = [2] x1 + [0] [split^#](x1) = [1] x1 + [2] [split#1^#](x1) = [1] x1 + [2] [bitonicSort#3^#](x1, x2, x3, x4) = [2] x4 + [2] [bitonicSort#4^#](x1, x2, x3, x4) = [2] x4 + [2] [div2#2^#](x1) = [0] [or^#](x1, x2) = [0] [#or^#](x1, x2) = [0] [split#2^#](x1, x2) = [1] x1 + [2] [split#3^#](x1, x2, x3) = [0] [splitAt#2^#](x1, x2) = [1] x2 + [1] [splitAt#3^#](x1, x2) = [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [zipWithOr#2^#](x1, x2, x3) = [0] [#succ^#](x1) = [0] [#pred^#](x1) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [2] x1 + [0] [c_5](x1, x2, x3) = [1] x1 + [2] x2 + [1] x3 + [0] [c_6](x1, x2) = [2] x1 + [1] x2 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1, x2) = [1] x1 + [1] x2 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1, x2) = [1] x1 + [2] x2 + [0] [c_15](x1) = [2] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [2] x1 + [0] [c_19](x1) = [1] x1 + [0] [c_20](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_21](x1) = [1] x1 + [0] [c_22](x1) = [1] x1 + [0] [c_26](x1) = [1] x1 + [0] [c_27](x1) = [1] x1 + [0] [c_29](x1, x2) = [1] x1 + [2] x2 + [0] [c_30](x1) = [1] x1 + [0] [c_31](x1) = [1] x1 + [0] [c_32](x1) = [1] x1 + [0] [c_33](x1) = [1] x1 + [0] [c_34](x1) = [1] x1 + [0] This order satisfies following ordering constraints [+(@x, @y)] = [2] @x + [1] @y + [0] >= [2] @x + [1] @y + [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1] @y + [4] > [1] @y + [2] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1] @y + [4] > [1] @y + [2] = [#pred(#add(#pos(#s(@x)), @y))] [append(@l, @ys)] = [2] @l + [1] @ys + [0] >= [2] @l + [1] @ys + [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [2] @xs + [1] @ys + [2] >= [2] @xs + [1] @ys + [2] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [1] @ys + [0] >= [1] @ys + [0] = [@ys] [append#2(@l', @x)] = [1] @l' + [2] > [1] @l' + [1] = [::(@x, @l')] [bitonicMerge#10(#false(), @hi, @low)] = [1] @hi + [1] @low + [2] > [1] @hi + [1] @low + [1] = [tuple#2(@low, @hi)] [bitonicMerge#10(#true(), @hi, @low)] = [1] @hi + [1] @low + [1] >= [1] @hi + [1] @low + [1] = [tuple#2(@hi, @low)] [length(@l)] = [0] >= [0] = [length#1(@l)] [div2(@n)] = [2] @n + [0] >= [2] @n + [0] = [div2#1(@n)] [splitAt(@n, @l)] = [1] @l + [1] @n + [1] >= [1] @l + [1] @n + [1] = [splitAt#1(@n, @l)] [bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [1] @zipWithOr@1 + [1] @zipWithOr@2 + [1] >= [1] @zipWithOr@1 + [1] @zipWithOr@2 + [1] = [zipWithOr(@zipWithOr@1, @zipWithOr@2)] [bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [1] @zipWithAnd@3 + [1] @zipWithAnd@4 + [1] >= [1] @zipWithAnd@3 + [1] @zipWithAnd@4 + [1] = [zipWithAnd(@zipWithAnd@3, @zipWithAnd@4)] [zipWithOr(@l1, @l2)] = [1] @l1 + [1] @l2 + [1] >= [1] @l1 + [1] @l2 + [1] = [zipWithOr#1(@l1, @l2)] [zipWithAnd(@l1, @l2)] = [1] @l1 + [1] @l2 + [1] >= [1] @l1 + [1] @l2 + [1] = [zipWithAnd#1(@l1, @l2)] [split(@l)] = [1] @l + [1] >= [1] @l + [1] = [split#1(@l)] [div2#1(#0())] = [0] >= [0] = [#0()] [div2#1(#s(@n))] = [2] @n + [4] > [2] @n + [2] = [div2#2(@n)] [div2#2(#0())] = [2] > [0] = [#0()] [div2#2(#s(@n))] = [2] @n + [6] > [2] @n + [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [0] >= [0] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [0] >= [0] = [#0()] [split#1(::(@x1, @xs))] = [1] @xs + [2] >= [1] @xs + [2] = [split#2(@xs, @x1)] [split#1(nil())] = [1] >= [1] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [1] @xs' + [3] >= [1] @xs' + [3] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [2] > [1] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [1] @l1 + [1] @l2 + [3] >= [1] @l1 + [1] @l2 + [3] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [splitAt#1(#0(), @l)] = [1] @l + [1] >= [1] @l + [1] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [1] @l + [1] @n' + [3] > [1] @l + [1] @n' + [2] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [1] @n' + [1] @xs + [3] >= [1] @n' + [1] @xs + [3] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [1] @n' + [2] > [1] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [1] @l1 + [1] @l2 + [3] > [1] @l1 + [1] @l2 + [2] = [tuple#2(::(@x, @l1), @l2)] [zipWithAnd#1(::(@x, @xs), @l2)] = [1] @l2 + [1] @xs + [2] >= [1] @l2 + [1] @xs + [2] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [1] @l2 + [1] > [0] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [1] @xs + [1] @ys + [3] > [1] @xs + [1] @ys + [2] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [1] @xs + [2] > [0] = [nil()] [zipWithOr#1(::(@x, @xs), @l2)] = [1] @l2 + [1] @xs + [2] >= [1] @l2 + [1] @xs + [2] = [zipWithOr#2(@l2, @x, @xs)] [zipWithOr#1(nil(), @l2)] = [1] @l2 + [1] > [0] = [nil()] [zipWithOr#2(::(@y, @ys), @x, @xs)] = [1] @xs + [1] @ys + [3] > [1] @xs + [1] @ys + [2] = [::(or(@x, @y), zipWithOr(@xs, @ys))] [zipWithOr#2(nil(), @x, @xs)] = [1] @xs + [2] > [0] = [nil()] [#pred(#0())] = [2] >= [2] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [2] > [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [2] > [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [4] > [2] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] >= [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] >= [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [2] > [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [2] >= [2] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] >= [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] >= [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [0] >= [0] = [c_3(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [0] >= [0] = [c_4(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [0] >= [0] = [c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l))] [bitonicMerge#3^#(@h, @direction, @l)] = [2] @h + [0] >= [1] @h + [0] = [c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l))] [div2^#(@n)] = [0] >= [0] = [c_7(div2#1^#(@n))] [length^#(@l)] = [0] >= [0] = [c_8(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] >= [0] = [c_9(length^#(@xs))] [div2#1^#(#s(@n))] = [0] >= [0] = [c_10(div2#2^#(@n))] [bitonicMerge#4^#(@s, @direction)] = [0] >= [0] = [c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s))] [splitAt^#(@n, @l)] = [1] @n + [0] >= [1] @n + [0] = [c_12(splitAt#1^#(@n, @l))] [splitAt#1^#(#s(@n'), @l)] = [1] @n' + [2] > [1] @n' + [1] = [c_13(splitAt#2^#(@l, @n'))] [bitonicMerge#5^#(@hi, @direction, @s)] = [0] >= [0] = [c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s))] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0] >= [0] = [c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [0] >= [0] = [c_16(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [0] >= [0] = [c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0] >= [0] = [c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [0] >= [0] = [c_19(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [0] >= [0] = [c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [zipWithOr#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_21(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_22(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [2] @l + [2] >= [2] @l + [2] = [bitonicSort#1^#(@l, @dir, @l)] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [2] @l + [2] >= [2] @l + [2] = [bitonicSort#2^#(split(@l), @dir)] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [2] @l + [2] >= [1] @l + [2] = [split^#(@l)] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [2] @l1 + [2] @l2 + [2] >= [2] @l1 + [2] = [bitonicSort^#(@l1, #true())] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [2] @l1 + [2] @l2 + [2] >= [2] @l2 + [2] = [bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)] [split^#(@l)] = [1] @l + [2] >= [1] @l + [2] = [c_26(split#1^#(@l))] [split#1^#(::(@x1, @xs))] = [1] @xs + [3] > [1] @xs + [2] = [c_27(split#2^#(@xs, @x1))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [2] @l2 + [2] >= [2] @l2 + [2] = [bitonicSort^#(@l2, #false())] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [2] @l2 + [2] >= [2] @l2 + [2] = [bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [2] @l2 + [2] > [0] = [c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2))] [div2#2^#(#s(@n))] = [0] >= [0] = [c_30(div2^#(@n))] [split#2^#(::(@x2, @xs'), @x1)] = [1] @xs' + [3] > [1] @xs' + [2] = [c_31(split^#(@xs'))] [splitAt#2^#(::(@x, @xs), @n')] = [1] @n' + [1] > [1] @n' + [0] = [c_32(splitAt^#(@n', @xs))] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_33(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_34(zipWithOr^#(@xs, @ys))] The strictly oriented rules are moved into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , split^#(@l) -> c_26(split#1^#(@l)) } Weak DPs: { div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> split^#(@l) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 19: split^#(@l) -> c_26(split#1^#(@l)) , 26: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> split^#(@l) , 31: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , 34: split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) } Trs: { and(@x, @y) -> #and(@x, @y) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , or(@x, @y) -> #or(@x, @y) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1, 2, 3}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1, 2}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1, 2}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1, 2, 3}, Uargs(c_21) = {1}, Uargs(c_22) = {1}, Uargs(c_26) = {1}, Uargs(c_27) = {1}, Uargs(c_29) = {1, 2}, Uargs(c_30) = {1}, Uargs(c_31) = {1}, Uargs(c_32) = {1}, Uargs(c_33) = {1}, Uargs(c_34) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [1] x2 + [0] [#add](x1, x2) = [1] x2 + [0] [and](x1, x2) = [2] x2 + [2] [#and](x1, x2) = [2] x2 + [0] [append](x1, x2) = [2] x1 + [2] x2 + [0] [append#1](x1, x2) = [2] x1 + [2] x2 + [0] [::](x1, x2) = [1] x2 + [1] [append#2](x1, x2) = [1] x1 + [1] [nil] = [0] [bitonicMerge](x1, x2) = [0] [bitonicMerge#1](x1, x2, x3) = [2] x2 + [1] x3 + [0] [bitonicMerge#2](x1, x2, x3) = [2] x2 + [1] x3 + [0] [#false] = [0] [bitonicMerge#10](x1, x2, x3) = [1] x2 + [1] x3 + [1] [tuple#2](x1, x2) = [1] x1 + [1] x2 + [1] [#true] = [0] [length](x1) = [1] [div2](x1) = [1] x1 + [0] [bitonicMerge#3](x1, x2, x3) = [2] x2 + [0] [splitAt](x1, x2) = [1] x1 + [0] [bitonicMerge#4](x1, x2) = [1] x1 + [2] x2 + [0] [bitonicMerge#6](x1) = [1] x1 + [0] [bitonicMerge#5](x1, x2, x3) = [1] x1 + [2] x2 + [2] x3 + [2] [bitonicMerge#8](x1) = [1] x1 + [0] [bitonicMerge#7](x1, x2, x3) = [0] [zipWithOr](x1, x2) = [1] x1 + [1] x2 + [1] [bitonicMerge#9](x1, x2) = [1] x1 + [0] [zipWithAnd](x1, x2) = [1] x2 + [0] [bitonicSort](x1, x2) = [0] [bitonicSort#1](x1, x2, x3) = [2] x2 + [0] [split](x1) = [1] x1 + [1] [bitonicSort#2](x1, x2) = [2] x2 + [0] [bitonicSort#3](x1, x2, x3, x4) = [2] x2 + [0] [bitonicSort#4](x1, x2, x3, x4) = [2] x2 + [0] [div2#1](x1) = [1] x1 + [0] [#0] = [1] [#s](x1) = [1] x1 + [0] [div2#2](x1) = [1] x1 + [0] [#pos](x1) = [1] x1 + [0] [length#1](x1) = [1] [or](x1, x2) = [2] x1 + [2] x2 + [2] [#or](x1, x2) = [0] [split#1](x1) = [1] x1 + [1] [split#2](x1, x2) = [1] x1 + [2] [split#3](x1, x2, x3) = [1] x1 + [2] [splitAt#1](x1, x2) = [1] x1 + [2] x2 + [0] [splitAt#2](x1, x2) = [2] x1 + [2] [splitAt#3](x1, x2) = [1] [zipWithAnd#1](x1, x2) = [1] x2 + [0] [zipWithAnd#2](x1, x2, x3) = [1] x1 + [0] [zipWithOr#1](x1, x2) = [1] x1 + [1] x2 + [1] [zipWithOr#2](x1, x2, x3) = [1] x1 + [1] x3 + [2] [#neg](x1) = [1] [#pred](x1) = [1] x1 + [0] [#succ](x1) = [1] x1 + [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [and^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [append^#](x1, x2) = [0] [append#1^#](x1, x2) = [0] [append#2^#](x1, x2) = [0] [bitonicMerge^#](x1, x2) = [0] [bitonicMerge#1^#](x1, x2, x3) = [0] [bitonicMerge#2^#](x1, x2, x3) = [0] [bitonicMerge#3^#](x1, x2, x3) = [0] [div2^#](x1) = [0] [length^#](x1) = [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [length#1^#](x1) = [0] [div2#1^#](x1) = [0] [bitonicMerge#4^#](x1, x2) = [0] [splitAt^#](x1, x2) = [0] [splitAt#1^#](x1, x2) = [0] [bitonicMerge#5^#](x1, x2, x3) = [0] [bitonicMerge#6^#](x1) = [0] [zipWithOr^#](x1, x2) = [0] [bitonicMerge#7^#](x1, x2, x3) = [0] [bitonicMerge#8^#](x1) = [0] [zipWithAnd^#](x1, x2) = [0] [bitonicMerge#9^#](x1, x2) = [0] [zipWithOr#1^#](x1, x2) = [0] [zipWithAnd#1^#](x1, x2) = [0] [bitonicSort^#](x1, x2) = [1] x1 + [1] x2 + [2] [bitonicSort#1^#](x1, x2, x3) = [1] x3 + [2] [bitonicSort#2^#](x1, x2) = [1] x1 + [1] [split^#](x1) = [1] x1 + [1] [split#1^#](x1) = [1] x1 + [0] [bitonicSort#3^#](x1, x2, x3, x4) = [1] x4 + [2] [bitonicSort#4^#](x1, x2, x3, x4) = [0] [div2#2^#](x1) = [0] [or^#](x1, x2) = [0] [#or^#](x1, x2) = [0] [split#2^#](x1, x2) = [1] x1 + [1] [split#3^#](x1, x2, x3) = [0] [splitAt#2^#](x1, x2) = [0] [splitAt#3^#](x1, x2) = [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [zipWithOr#2^#](x1, x2, x3) = [0] [#succ^#](x1) = [0] [#pred^#](x1) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [c_6](x1, x2) = [2] x1 + [1] x2 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1) = [1] x1 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_11](x1, x2) = [1] x1 + [1] x2 + [0] [c_12](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_14](x1, x2) = [1] x1 + [1] x2 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] [c_19](x1) = [1] x1 + [0] [c_20](x1, x2, x3) = [2] x1 + [1] x2 + [1] x3 + [0] [c_21](x1) = [2] x1 + [0] [c_22](x1) = [2] x1 + [0] [c_26](x1) = [1] x1 + [0] [c_27](x1) = [1] x1 + [0] [c_29](x1, x2) = [1] x1 + [1] x2 + [0] [c_30](x1) = [1] x1 + [0] [c_31](x1) = [1] x1 + [0] [c_32](x1) = [1] x1 + [0] [c_33](x1) = [2] x1 + [0] [c_34](x1) = [1] x1 + [0] This order satisfies following ordering constraints [+(@x, @y)] = [1] @y + [0] >= [1] @y + [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1] @y + [0] >= [1] @y + [0] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1] @y + [0] >= [1] @y + [0] = [#pred(#add(#pos(#s(@x)), @y))] [append(@l, @ys)] = [2] @l + [2] @ys + [0] >= [2] @l + [2] @ys + [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [2] @xs + [2] @ys + [2] > [2] @xs + [2] @ys + [1] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [2] @ys + [0] >= [1] @ys + [0] = [@ys] [append#2(@l', @x)] = [1] @l' + [1] >= [1] @l' + [1] = [::(@x, @l')] [bitonicMerge#10(#false(), @hi, @low)] = [1] @hi + [1] @low + [1] >= [1] @hi + [1] @low + [1] = [tuple#2(@low, @hi)] [bitonicMerge#10(#true(), @hi, @low)] = [1] @hi + [1] @low + [1] >= [1] @hi + [1] @low + [1] = [tuple#2(@hi, @low)] [length(@l)] = [1] >= [1] = [length#1(@l)] [div2(@n)] = [1] @n + [0] >= [1] @n + [0] = [div2#1(@n)] [bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [1] @zipWithOr@1 + [1] @zipWithOr@2 + [1] >= [1] @zipWithOr@1 + [1] @zipWithOr@2 + [1] = [zipWithOr(@zipWithOr@1, @zipWithOr@2)] [bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [1] @zipWithAnd@3 + [1] @zipWithAnd@4 + [1] > [1] @zipWithAnd@4 + [0] = [zipWithAnd(@zipWithAnd@3, @zipWithAnd@4)] [zipWithOr(@l1, @l2)] = [1] @l1 + [1] @l2 + [1] >= [1] @l1 + [1] @l2 + [1] = [zipWithOr#1(@l1, @l2)] [zipWithAnd(@l1, @l2)] = [1] @l2 + [0] >= [1] @l2 + [0] = [zipWithAnd#1(@l1, @l2)] [split(@l)] = [1] @l + [1] >= [1] @l + [1] = [split#1(@l)] [div2#1(#0())] = [1] >= [1] = [#0()] [div2#1(#s(@n))] = [1] @n + [0] >= [1] @n + [0] = [div2#2(@n)] [div2#2(#0())] = [1] >= [1] = [#0()] [div2#2(#s(@n))] = [1] @n + [0] >= [1] @n + [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [1] >= [1] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [1] >= [1] = [#0()] [split#1(::(@x1, @xs))] = [1] @xs + [2] >= [1] @xs + [2] = [split#2(@xs, @x1)] [split#1(nil())] = [1] >= [1] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [1] @xs' + [3] >= [1] @xs' + [3] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [2] > [1] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [1] @l1 + [1] @l2 + [3] >= [1] @l1 + [1] @l2 + [3] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [zipWithAnd#1(::(@x, @xs), @l2)] = [1] @l2 + [0] >= [1] @l2 + [0] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [1] @l2 + [0] >= [0] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [1] @ys + [1] >= [1] @ys + [1] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [0] >= [0] = [nil()] [zipWithOr#1(::(@x, @xs), @l2)] = [1] @l2 + [1] @xs + [2] >= [1] @l2 + [1] @xs + [2] = [zipWithOr#2(@l2, @x, @xs)] [zipWithOr#1(nil(), @l2)] = [1] @l2 + [1] > [0] = [nil()] [zipWithOr#2(::(@y, @ys), @x, @xs)] = [1] @xs + [1] @ys + [3] > [1] @xs + [1] @ys + [2] = [::(or(@x, @y), zipWithOr(@xs, @ys))] [zipWithOr#2(nil(), @x, @xs)] = [1] @xs + [2] > [0] = [nil()] [#pred(#0())] = [1] >= [1] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [1] >= [1] = [#0()] [#pred(#pos(#s(#s(@x))))] = [1] @x + [0] >= [1] @x + [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [1] >= [1] = [#neg(#s(#s(@x)))] [#succ(#0())] = [1] >= [1] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [1] @x + [0] >= [1] @x + [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [1] >= [1] = [#0()] [#succ(#neg(#s(#s(@x))))] = [1] >= [1] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] >= [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] >= [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [0] >= [0] = [c_3(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [0] >= [0] = [c_4(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [0] >= [0] = [c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l))] [bitonicMerge#3^#(@h, @direction, @l)] = [0] >= [0] = [c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l))] [div2^#(@n)] = [0] >= [0] = [c_7(div2#1^#(@n))] [length^#(@l)] = [0] >= [0] = [c_8(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] >= [0] = [c_9(length^#(@xs))] [div2#1^#(#s(@n))] = [0] >= [0] = [c_10(div2#2^#(@n))] [bitonicMerge#4^#(@s, @direction)] = [0] >= [0] = [c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s))] [splitAt^#(@n, @l)] = [0] >= [0] = [c_12(splitAt#1^#(@n, @l))] [splitAt#1^#(#s(@n'), @l)] = [0] >= [0] = [c_13(splitAt#2^#(@l, @n'))] [bitonicMerge#5^#(@hi, @direction, @s)] = [0] >= [0] = [c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s))] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0] >= [0] = [c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [0] >= [0] = [c_16(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [0] >= [0] = [c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0] >= [0] = [c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [0] >= [0] = [c_19(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [0] >= [0] = [c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [zipWithOr#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_21(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_22(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [1] @dir + [1] @l + [2] >= [1] @l + [2] = [bitonicSort#1^#(@l, @dir, @l)] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [1] @l + [2] >= [1] @l + [2] = [bitonicSort#2^#(split(@l), @dir)] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [1] @l + [2] > [1] @l + [1] = [split^#(@l)] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [1] @l1 + [1] @l2 + [2] >= [1] @l1 + [2] = [bitonicSort^#(@l1, #true())] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [1] @l1 + [1] @l2 + [2] >= [1] @l2 + [2] = [bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)] [split^#(@l)] = [1] @l + [1] > [1] @l + [0] = [c_26(split#1^#(@l))] [split#1^#(::(@x1, @xs))] = [1] @xs + [1] >= [1] @xs + [1] = [c_27(split#2^#(@xs, @x1))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [1] @l2 + [2] >= [1] @l2 + [2] = [bitonicSort^#(@l2, #false())] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [1] @l2 + [2] > [0] = [bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [0] >= [0] = [c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2))] [div2#2^#(#s(@n))] = [0] >= [0] = [c_30(div2^#(@n))] [split#2^#(::(@x2, @xs'), @x1)] = [1] @xs' + [2] > [1] @xs' + [1] = [c_31(split^#(@xs'))] [splitAt#2^#(::(@x, @xs), @n')] = [0] >= [0] = [c_32(splitAt^#(@n', @xs))] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_33(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_34(zipWithOr^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , 2: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , 3: bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , 4: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , 5: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , 6: bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , 7: div2^#(@n) -> c_7(div2#1^#(@n)) , 8: length^#(@l) -> c_8(length#1^#(@l)) , 9: length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , 10: bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , 11: splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , 12: bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , 13: bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , 14: zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , 15: bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , 16: bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , 17: zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , 18: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , 19: split^#(@l) -> c_26(split#1^#(@l)) , 20: div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , 21: splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , 22: zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , 23: zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , 24: bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , 25: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , 26: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> split^#(@l) , 27: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , 28: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , 29: split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , 30: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , 31: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , 32: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , 33: div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , 34: split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , 35: splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , 36: zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , 37: zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {19,26,31,34}. These cover all (indirect) predecessors of dependency pairs {19,26,29,31,32,34}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) } Weak DPs: { div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> split^#(@l) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , split^#(@l) -> c_26(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { bitonicSort#1^#(::(@x, @xs), @dir, @l) -> split^#(@l) , split^#(@l) -> c_26(split#1^#(@l)) , split#1^#(::(@x1, @xs)) -> c_27(split#2^#(@xs, @x1)) , split#2^#(::(@x2, @xs'), @x1) -> c_31(split^#(@xs')) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) } Weak DPs: { div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 5: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , 19: div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , 29: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , 30: div2#2^#(#s(@n)) -> c_30(div2^#(@n)) } Trs: { append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , bitonicMerge#2(nil(), @direction, @l) -> @l , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1, 2, 3}, Uargs(c_6) = {1, 2}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1, 2}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1, 2}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1, 2, 3}, Uargs(c_21) = {1}, Uargs(c_22) = {1}, Uargs(c_29) = {1, 2}, Uargs(c_30) = {1}, Uargs(c_32) = {1}, Uargs(c_33) = {1}, Uargs(c_34) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [+](x1, x2) = [1 1] x1 + [1 2] x2 + [0] [0 2] [0 1] [0] [#add](x1, x2) = [1 0] x1 + [1 1] x2 + [0] [0 2] [0 1] [0] [and](x1, x2) = [0] [1] [#and](x1, x2) = [0] [0] [append](x1, x2) = [2 0] x1 + [2 0] x2 + [0] [0 0] [0 1] [0] [append#1](x1, x2) = [2 0] x1 + [2 0] x2 + [0] [0 0] [0 1] [0] [::](x1, x2) = [1 0] x2 + [1] [0 1] [0] [append#2](x1, x2) = [1 0] x1 + [1] [0 1] [0] [nil] = [0] [0] [bitonicMerge](x1, x2) = [0 0] x1 + [0] [1 1] [2] [bitonicMerge#1](x1, x2, x3) = [2 0] x2 + [1 0] x3 + [0] [2 2] [0 1] [0] [bitonicMerge#2](x1, x2, x3) = [2 0] x2 + [2 0] x3 + [2] [2 2] [0 1] [2] [#false] = [2] [1] [bitonicMerge#10](x1, x2, x3) = [2 2] x2 + [2 0] x3 + [0] [1 1] [1 1] [0] [tuple#2](x1, x2) = [1 0] x1 + [0 0] x2 + [0] [1 0] [1 1] [0] [#true] = [2] [1] [length](x1) = [2 0] x1 + [2] [0 0] [0] [div2](x1) = [0] [0] [bitonicMerge#3](x1, x2, x3) = [2 0] x2 + [1 0] x3 + [2] [2 2] [0 0] [2] [splitAt](x1, x2) = [1 0] x1 + [0 0] x2 + [0] [0 0] [2 1] [0] [bitonicMerge#4](x1, x2) = [2 0] x1 + [0 0] x2 + [2] [2 0] [2 2] [2] [bitonicMerge#6](x1) = [1 0] x1 + [0] [0 0] [0] [bitonicMerge#5](x1, x2, x3) = [0 1] x1 + [0 0] x2 + [2 0] x3 + [0] [0 1] [2 0] [2 1] [0] [bitonicMerge#8](x1) = [1 0] x1 + [0] [0 0] [0] [bitonicMerge#7](x1, x2, x3) = [0 0] x1 + [2 1] x3 + [0] [2 0] [2 2] [0] [zipWithOr](x1, x2) = [1 0] x1 + [0] [0 0] [0] [bitonicMerge#9](x1, x2) = [0 0] x1 + [0] [2 0] [0] [zipWithAnd](x1, x2) = [1 0] x1 + [0] [0 0] [0] [bitonicSort](x1, x2) = [0 0] x1 + [0] [0 1] [0] [bitonicSort#1](x1, x2, x3) = [0] [0] [split](x1) = [1 0] x1 + [1] [1 0] [0] [bitonicSort#2](x1, x2) = [0] [2] [bitonicSort#3](x1, x2, x3, x4) = [2 0] x2 + [2 0] x4 + [0] [2 2] [2 2] [2] [bitonicSort#4](x1, x2, x3, x4) = [0 0] x3 + [0] [0 2] [2] [div2#1](x1) = [0] [0] [#0] = [0] [0] [#s](x1) = [1 0] x1 + [1] [0 1] [2] [div2#2](x1) = [0] [0] [#pos](x1) = [0] [0] [length#1](x1) = [2 0] x1 + [2] [0 0] [0] [or](x1, x2) = [2] [1] [#or](x1, x2) = [0] [0] [split#1](x1) = [1 0] x1 + [1] [1 0] [0] [split#2](x1, x2) = [1 0] x1 + [2] [1 0] [1] [split#3](x1, x2, x3) = [1 0] x1 + [2] [0 1] [2] [splitAt#1](x1, x2) = [1 0] x1 + [0 0] x2 + [0] [0 0] [2 1] [0] [splitAt#2](x1, x2) = [0 0] x1 + [1 0] x2 + [1] [2 1] [0 0] [0] [splitAt#3](x1, x2) = [1 0] x1 + [1] [0 1] [1] [zipWithAnd#1](x1, x2) = [1 0] x1 + [0] [0 0] [0] [zipWithAnd#2](x1, x2, x3) = [1 0] x3 + [1] [0 0] [0] [zipWithOr#1](x1, x2) = [1 0] x1 + [0] [0 0] [0] [zipWithOr#2](x1, x2, x3) = [1 0] x3 + [1] [0 0] [0] [#neg](x1) = [2] [1] [#pred](x1) = [0 1] x1 + [2] [0 1] [2] [#succ](x1) = [1 0] x1 + [0] [0 1] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [and^#](x1, x2) = [0] [0] [#and^#](x1, x2) = [0] [0] [append^#](x1, x2) = [0] [0] [append#1^#](x1, x2) = [0] [0] [append#2^#](x1, x2) = [0] [0] [bitonicMerge^#](x1, x2) = [1 0] x1 + [0] [0 1] [0] [bitonicMerge#1^#](x1, x2, x3) = [1 0] x1 + [0] [0 0] [0] [bitonicMerge#2^#](x1, x2, x3) = [1 0] x1 + [1] [0 0] [1] [bitonicMerge#3^#](x1, x2, x3) = [2 2] x1 + [0] [0 1] [1] [div2^#](x1) = [0 1] x1 + [0] [0 0] [0] [length^#](x1) = [0] [1] [bitonicMerge#10^#](x1, x2, x3) = [0] [0] [length#1^#](x1) = [0] [0] [div2#1^#](x1) = [0 1] x1 + [0] [0 0] [0] [bitonicMerge#4^#](x1, x2) = [2 0] x1 + [0] [0 0] [0] [splitAt^#](x1, x2) = [0 2] x1 + [0] [0 0] [1] [splitAt#1^#](x1, x2) = [0 2] x1 + [0] [0 0] [0] [bitonicMerge#5^#](x1, x2, x3) = [1 1] x1 + [1 0] x3 + [0] [0 0] [0 0] [0] [bitonicMerge#6^#](x1) = [0] [0] [zipWithOr^#](x1, x2) = [0] [0] [bitonicMerge#7^#](x1, x2, x3) = [1 1] x1 + [1 1] x3 + [0] [0 0] [0 0] [0] [bitonicMerge#8^#](x1) = [0] [0] [zipWithAnd^#](x1, x2) = [0 0] x1 + [0 0] x2 + [0] [1 1] [1 0] [1] [bitonicMerge#9^#](x1, x2) = [0 1] x1 + [0] [0 0] [0] [zipWithOr#1^#](x1, x2) = [0] [0] [zipWithAnd#1^#](x1, x2) = [0] [0] [bitonicSort^#](x1, x2) = [2 0] x1 + [2] [0 0] [0] [bitonicSort#1^#](x1, x2, x3) = [2 0] x3 + [2] [0 0] [0] [bitonicSort#2^#](x1, x2) = [0 2] x1 + [2] [0 0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [bitonicSort#3^#](x1, x2, x3, x4) = [2 0] x3 + [2 2] x4 + [2] [0 0] [0 0] [0] [bitonicSort#4^#](x1, x2, x3, x4) = [2 0] x3 + [2 2] x4 + [2] [0 0] [0 0] [0] [div2#2^#](x1) = [0 1] x1 + [0] [0 0] [0] [or^#](x1, x2) = [0] [0] [#or^#](x1, x2) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [splitAt#2^#](x1, x2) = [0 2] x2 + [0] [0 0] [2] [splitAt#3^#](x1, x2) = [0] [0] [zipWithAnd#2^#](x1, x2, x3) = [0 0] x3 + [0] [1 0] [1] [zipWithOr#2^#](x1, x2, x3) = [0] [0] [#succ^#](x1) = [0] [0] [#pred^#](x1) = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [0] [c_2](x1) = [1 0] x1 + [0] [0 0] [0] [c_3](x1) = [1 0] x1 + [0] [0 0] [0] [c_4](x1) = [1 0] x1 + [0] [0 0] [0] [c_5](x1, x2, x3) = [1 1] x1 + [2 0] x2 + [1 0] x3 + [0] [0 0] [0 0] [0 0] [0] [c_6](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_8](x1) = [1 0] x1 + [0] [0 0] [0] [c_9](x1) = [1 0] x1 + [0] [0 0] [0] [c_10](x1) = [1 1] x1 + [0] [0 0] [0] [c_11](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_12](x1) = [1 0] x1 + [0] [0 0] [0] [c_13](x1) = [1 2] x1 + [0] [0 0] [0] [c_14](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_15](x1) = [2 0] x1 + [0] [0 0] [0] [c_16](x1) = [1 0] x1 + [0] [0 0] [0] [c_17](x1) = [1 0] x1 + [0] [0 0] [0] [c_18](x1) = [2 0] x1 + [0] [0 0] [0] [c_19](x1) = [1 0] x1 + [0] [0 0] [0] [c_20](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 0] x3 + [0] [0 0] [0 0] [0 0] [0] [c_21](x1) = [1 0] x1 + [0] [0 0] [0] [c_22](x1) = [2 0] x1 + [0] [0 0] [0] [c_26](x1) = [0] [0] [c_27](x1) = [0] [0] [c_29](x1, x2) = [1 2] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_30](x1) = [1 1] x1 + [0] [0 0] [0] [c_31](x1) = [0] [0] [c_32](x1) = [1 0] x1 + [0] [0 0] [0] [c_33](x1) = [1 0] x1 + [0] [0 0] [0] [c_34](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [+(@x, @y)] = [1 1] @x + [1 2] @y + [0] [0 2] [0 1] [0] >= [1 0] @x + [1 1] @y + [0] [0 2] [0 1] [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1 1] @y + [0] [0 1] [0] >= [1 0] @y + [0] [0 1] [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1 1] @y + [0] [0 1] [0] >= [1 0] @y + [0] [0 1] [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1 1] @y + [0] [0 1] [0] >= [1 1] @y + [0] [0 1] [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1 1] @y + [2] [0 1] [2] >= [0 1] @y + [2] [0 1] [2] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1 1] @y + [2] [0 1] [2] >= [0 1] @y + [2] [0 1] [2] = [#pred(#add(#pos(#s(@x)), @y))] [append(@l, @ys)] = [2 0] @l + [2 0] @ys + [0] [0 0] [0 1] [0] >= [2 0] @l + [2 0] @ys + [0] [0 0] [0 1] [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [2 0] @xs + [2 0] @ys + [2] [0 0] [0 1] [0] > [2 0] @xs + [2 0] @ys + [1] [0 0] [0 1] [0] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [2 0] @ys + [0] [0 1] [0] >= [1 0] @ys + [0] [0 1] [0] = [@ys] [append#2(@l', @x)] = [1 0] @l' + [1] [0 1] [0] >= [1 0] @l' + [1] [0 1] [0] = [::(@x, @l')] [bitonicMerge#10(#false(), @hi, @low)] = [2 2] @hi + [2 0] @low + [0] [1 1] [1 1] [0] >= [0 0] @hi + [1 0] @low + [0] [1 1] [1 0] [0] = [tuple#2(@low, @hi)] [bitonicMerge#10(#true(), @hi, @low)] = [2 2] @hi + [2 0] @low + [0] [1 1] [1 1] [0] >= [1 0] @hi + [0 0] @low + [0] [1 0] [1 1] [0] = [tuple#2(@hi, @low)] [length(@l)] = [2 0] @l + [2] [0 0] [0] >= [2 0] @l + [2] [0 0] [0] = [length#1(@l)] [div2(@n)] = [0] [0] >= [0] [0] = [div2#1(@n)] [splitAt(@n, @l)] = [0 0] @l + [1 0] @n + [0] [2 1] [0 0] [0] >= [0 0] @l + [1 0] @n + [0] [2 1] [0 0] [0] = [splitAt#1(@n, @l)] [bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [1 0] @zipWithOr@1 + [0] [0 0] [0] >= [1 0] @zipWithOr@1 + [0] [0 0] [0] = [zipWithOr(@zipWithOr@1, @zipWithOr@2)] [bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [1 0] @zipWithAnd@3 + [0] [0 0] [0] >= [1 0] @zipWithAnd@3 + [0] [0 0] [0] = [zipWithAnd(@zipWithAnd@3, @zipWithAnd@4)] [zipWithOr(@l1, @l2)] = [1 0] @l1 + [0] [0 0] [0] >= [1 0] @l1 + [0] [0 0] [0] = [zipWithOr#1(@l1, @l2)] [zipWithAnd(@l1, @l2)] = [1 0] @l1 + [0] [0 0] [0] >= [1 0] @l1 + [0] [0 0] [0] = [zipWithAnd#1(@l1, @l2)] [split(@l)] = [1 0] @l + [1] [1 0] [0] >= [1 0] @l + [1] [1 0] [0] = [split#1(@l)] [div2#1(#0())] = [0] [0] >= [0] [0] = [#0()] [div2#1(#s(@n))] = [0] [0] >= [0] [0] = [div2#2(@n)] [div2#2(#0())] = [0] [0] >= [0] [0] = [#0()] [div2#2(#s(@n))] = [0] [0] >= [0] [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [2 0] @xs + [4] [0 0] [0] > [2 0] @xs + [2] [0 0] [0] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [2] [0] > [0] [0] = [#0()] [split#1(::(@x1, @xs))] = [1 0] @xs + [2] [1 0] [1] >= [1 0] @xs + [2] [1 0] [1] = [split#2(@xs, @x1)] [split#1(nil())] = [1] [0] > [0] [0] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [1 0] @xs' + [3] [1 0] [2] >= [1 0] @xs' + [3] [1 0] [2] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [2] [1] > [0] [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [1 0] @l1 + [0 0] @l2 + [2] [1 0] [1 1] [2] > [1 0] @l1 + [0 0] @l2 + [1] [1 0] [1 1] [2] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [splitAt#1(#0(), @l)] = [0 0] @l + [0] [2 1] [0] >= [0 0] @l + [0] [1 1] [0] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [0 0] @l + [1 0] @n' + [1] [2 1] [0 0] [0] >= [0 0] @l + [1 0] @n' + [1] [2 1] [0 0] [0] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [1 0] @n' + [0 0] @xs + [1] [0 0] [2 1] [2] >= [1 0] @n' + [0 0] @xs + [1] [0 0] [2 1] [1] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [1 0] @n' + [1] [0 0] [0] > [0] [0] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [1 0] @l1 + [0 0] @l2 + [1] [1 0] [1 1] [1] >= [1 0] @l1 + [0 0] @l2 + [1] [1 0] [1 1] [1] = [tuple#2(::(@x, @l1), @l2)] [zipWithAnd#1(::(@x, @xs), @l2)] = [1 0] @xs + [1] [0 0] [0] >= [1 0] @xs + [1] [0 0] [0] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [0] [0] >= [0] [0] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [1 0] @xs + [1] [0 0] [0] >= [1 0] @xs + [1] [0 0] [0] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [1 0] @xs + [1] [0 0] [0] > [0] [0] = [nil()] [zipWithOr#1(::(@x, @xs), @l2)] = [1 0] @xs + [1] [0 0] [0] >= [1 0] @xs + [1] [0 0] [0] = [zipWithOr#2(@l2, @x, @xs)] [zipWithOr#1(nil(), @l2)] = [0] [0] >= [0] [0] = [nil()] [zipWithOr#2(::(@y, @ys), @x, @xs)] = [1 0] @xs + [1] [0 0] [0] >= [1 0] @xs + [1] [0 0] [0] = [::(or(@x, @y), zipWithOr(@xs, @ys))] [zipWithOr#2(nil(), @x, @xs)] = [1 0] @xs + [1] [0 0] [0] > [0] [0] = [nil()] [#pred(#0())] = [2] [2] >= [2] [1] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [2] [2] > [0] [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [2] [2] > [0] [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [3] [3] > [2] [1] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] [0] >= [0] [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] [0] >= [0] [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [2] [1] > [0] [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [2] [1] >= [2] [1] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] [0] >= [0] [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] [0] >= [0] [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [1 0] @l + [0] [0 1] [0] >= [1 0] @l + [0] [0 0] [0] = [c_3(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [1 0] @xs + [1] [0 0] [0] >= [1 0] @xs + [1] [0 0] [0] = [c_4(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [1 0] @ys + [2] [0 0] [1] > [1] [0] = [c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l))] [bitonicMerge#3^#(@h, @direction, @l)] = [2 2] @h + [0] [0 1] [1] >= [2 2] @h + [0] [0 0] [0] = [c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l))] [div2^#(@n)] = [0 1] @n + [0] [0 0] [0] >= [0 1] @n + [0] [0 0] [0] = [c_7(div2#1^#(@n))] [length^#(@l)] = [0] [1] >= [0] [0] = [c_8(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] [0] >= [0] [0] = [c_9(length^#(@xs))] [div2#1^#(#s(@n))] = [0 1] @n + [2] [0 0] [0] > [0 1] @n + [0] [0 0] [0] = [c_10(div2#2^#(@n))] [bitonicMerge#4^#(@s, @direction)] = [2 0] @s + [0] [0 0] [0] >= [2 0] @s + [0] [0 0] [0] = [c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s))] [splitAt^#(@n, @l)] = [0 2] @n + [0] [0 0] [1] >= [0 2] @n + [0] [0 0] [0] = [c_12(splitAt#1^#(@n, @l))] [splitAt#1^#(#s(@n'), @l)] = [0 2] @n' + [4] [0 0] [0] >= [0 2] @n' + [4] [0 0] [0] = [c_13(splitAt#2^#(@l, @n'))] [bitonicMerge#5^#(@hi, @direction, @s)] = [1 1] @hi + [1 0] @s + [0] [0 0] [0 0] [0] >= [1 1] @hi + [1 0] @s + [0] [0 0] [0 0] [0] = [c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s))] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0] [0] >= [0] [0] = [c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [0] [0] >= [0] [0] = [c_16(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [1 1] @hi + [1 1] @low + [0] [0 0] [0 0] [0] >= [1 1] @hi + [1 1] @low + [0] [0 0] [0 0] [0] = [c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0] [0] >= [0] [0] = [c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [0 0] @l1 + [0 0] @l2 + [0] [1 1] [1 0] [1] >= [0] [0] = [c_19(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1 0] @hi + [1 1] @low + [0] [0 0] [0 0] [0] >= [1 0] @hi + [1 1] @low + [0] [0 0] [0 0] [0] = [c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [zipWithOr#1^#(::(@x, @xs), @l2)] = [0] [0] >= [0] [0] = [c_21(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [0] [0] >= [0] [0] = [c_22(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [2 0] @l + [2] [0 0] [0] >= [2 0] @l + [2] [0 0] [0] = [bitonicSort#1^#(@l, @dir, @l)] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [2 0] @l + [2] [0 0] [0] >= [2 0] @l + [2] [0 0] [0] = [bitonicSort#2^#(split(@l), @dir)] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [2 0] @l1 + [2 2] @l2 + [2] [0 0] [0 0] [0] >= [2 0] @l1 + [2] [0 0] [0] = [bitonicSort^#(@l1, #true())] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [2 0] @l1 + [2 2] @l2 + [2] [0 0] [0 0] [0] >= [2 0] @l1 + [2 2] @l2 + [2] [0 0] [0 0] [0] = [bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [2 0] @l1 + [2 2] @l2 + [2] [0 0] [0 0] [0] >= [2 0] @l2 + [2] [0 0] [0] = [bitonicSort^#(@l2, #false())] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [2 0] @l1 + [2 2] @l2 + [2] [0 0] [0 0] [0] >= [2 0] @l1 + [2 2] @l2 + [2] [0 0] [0 0] [0] = [bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [2 0] @l1 + [2 2] @l2 + [2] [0 0] [0 0] [0] > [2 0] @l1 + [2 2] @l2 + [0] [0 0] [0 0] [0] = [c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2))] [div2#2^#(#s(@n))] = [0 1] @n + [2] [0 0] [0] > [0 1] @n + [0] [0 0] [0] = [c_30(div2^#(@n))] [splitAt#2^#(::(@x, @xs), @n')] = [0 2] @n' + [0] [0 0] [2] >= [0 2] @n' + [0] [0 0] [0] = [c_32(splitAt^#(@n', @xs))] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [0 0] @xs + [0] [1 0] [1] >= [0] [0] = [c_33(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [0] [0] >= [0] [0] = [c_34(zipWithOr^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , 2: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , 3: bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , 4: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , 5: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , 6: bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , 7: div2^#(@n) -> c_7(div2#1^#(@n)) , 8: length^#(@l) -> c_8(length#1^#(@l)) , 9: length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , 10: bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , 11: splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , 12: bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , 13: bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , 14: zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , 15: bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , 16: bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , 17: zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) , 18: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , 19: div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , 20: splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , 21: zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , 22: zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , 23: bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , 24: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , 25: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , 26: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , 27: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , 28: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , 29: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , 30: div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , 31: splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , 32: zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , 33: zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {5,19,29,30}. These cover all (indirect) predecessors of dependency pairs {3,4,5,6,7,10,12,13,15,16,18,19,29,30}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) } Weak DPs: { bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , div2^#(@n) -> c_7(div2#1^#(@n)) , div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { div2^#(@n) -> c_7(div2#1^#(@n)) , div2#1^#(#s(@n)) -> c_10(div2#2^#(@n)) , div2#2^#(#s(@n)) -> c_30(div2^#(@n)) } We apply the transformation 'simpDPRHS' on the sub-problem: Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , length^#(@l) -> c_8(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_9(length^#(@xs)) , splitAt^#(@n, @l) -> c_12(splitAt#1^#(@n, @l)) , zipWithOr^#(@l1, @l2) -> c_16(zipWithOr#1^#(@l1, @l2)) , zipWithAnd^#(@l1, @l2) -> c_19(zipWithAnd#1^#(@l1, @l2)) } Weak DPs: { bitonicMerge^#(@l, @direction) -> c_3(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_4(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_6(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_17(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_18(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_20(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_21(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_22(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_29(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , splitAt#2^#(::(@x, @xs), @n') -> c_32(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_33(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_34(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_5(bitonicMerge#3^#(div2(length(@l)), @direction, @l), div2^#(length(@l)), length^#(@l)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , length^#(@l) -> c_3(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_4(length^#(@xs)) , splitAt^#(@n, @l) -> c_5(splitAt#1^#(@n, @l)) , zipWithOr^#(@l1, @l2) -> c_6(zipWithOr#1^#(@l1, @l2)) , zipWithAnd^#(@l1, @l2) -> c_7(zipWithAnd#1^#(@l1, @l2)) } Weak DPs: { bitonicMerge^#(@l, @direction) -> c_8(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_9(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_11(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , bitonicMerge#4^#(@s, @direction) -> c_12(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_16(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_17(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_18(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_19(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_20(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_21(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_22(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_23(bitonicSort^#(@l1, #true())) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_24(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_25(bitonicSort^#(@l2, #false())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_26(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_27(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , splitAt#2^#(::(@x, @xs), @n') -> c_28(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_29(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_30(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 4: length#1^#(::(@x, @xs)) -> c_4(length^#(@xs)) , 26: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_26(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) } Trs: { split#2(nil(), @x1) -> tuple#2(nil(), nil()) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1, 2}, Uargs(c_11) = {1, 2}, Uargs(c_12) = {1, 2}, Uargs(c_13) = {1}, Uargs(c_14) = {1, 2}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1, 2, 3}, Uargs(c_19) = {1}, Uargs(c_20) = {1}, Uargs(c_21) = {1}, Uargs(c_22) = {1}, Uargs(c_23) = {1}, Uargs(c_24) = {1}, Uargs(c_25) = {1}, Uargs(c_26) = {1}, Uargs(c_27) = {1, 2}, Uargs(c_28) = {1}, Uargs(c_29) = {1}, Uargs(c_30) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [+](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [2 2] [2 1] [1] [#add](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [2 1] [1] [and](x1, x2) = [0] [0] [#and](x1, x2) = [0] [0] [append](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 2] [0 1] [2] [append#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 2] [0 1] [2] [::](x1, x2) = [1 2] x1 + [1 0] x2 + [1] [0 0] [0 1] [1] [append#2](x1, x2) = [1 0] x1 + [1 2] x2 + [1] [0 1] [0 0] [2] [nil] = [0] [0] [bitonicMerge](x1, x2) = [0 0] x1 + [0] [0 1] [1] [bitonicMerge#1](x1, x2, x3) = [2 0] x2 + [1 0] x3 + [0] [2 2] [0 1] [0] [bitonicMerge#2](x1, x2, x3) = [2 0] x2 + [2 0] x3 + [0] [1 2] [2 2] [0] [#false] = [0] [0] [bitonicMerge#10](x1, x2, x3) = [1 0] x2 + [1 0] x3 + [0] [1 1] [1 2] [0] [tuple#2](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [0 0] [0] [#true] = [0] [0] [length](x1) = [0 0] x1 + [0] [1 0] [2] [div2](x1) = [0 0] x1 + [0] [0 2] [0] [bitonicMerge#3](x1, x2, x3) = [0] [0] [splitAt](x1, x2) = [0 0] x1 + [1 0] x2 + [0] [1 0] [0 0] [0] [bitonicMerge#4](x1, x2) = [2 0] x2 + [0] [2 2] [0] [bitonicMerge#6](x1) = [0 1] x1 + [0] [0 1] [0] [bitonicMerge#5](x1, x2, x3) = [0 0] x2 + [0] [2 2] [0] [bitonicMerge#8](x1) = [0 1] x1 + [0] [0 1] [0] [bitonicMerge#7](x1, x2, x3) = [1 0] x1 + [0 0] x2 + [2 0] x3 + [0] [0 0] [0 2] [2 2] [0] [zipWithOr](x1, x2) = [0 1] x1 + [0] [0 1] [0] [bitonicMerge#9](x1, x2) = [1 0] x1 + [0] [0 0] [0] [zipWithAnd](x1, x2) = [0 1] x1 + [0] [0 1] [0] [bitonicSort](x1, x2) = [0 1] x1 + [0] [1 1] [0] [bitonicSort#1](x1, x2, x3) = [0] [0] [split](x1) = [1 0] x1 + [0] [1 0] [2] [bitonicSort#2](x1, x2) = [1 0] x2 + [0] [2 1] [0] [bitonicSort#3](x1, x2, x3, x4) = [2 0] x4 + [0] [2 2] [0] [bitonicSort#4](x1, x2, x3, x4) = [0 0] x1 + [2 0] x2 + [0 0] x3 + [0 0] x4 + [0] [1 1] [2 2] [2 0] [0 2] [0] [div2#1](x1) = [0 0] x1 + [0] [0 2] [0] [#0] = [0] [2] [#s](x1) = [1 0] x1 + [2] [0 1] [1] [div2#2](x1) = [0 0] x1 + [0] [0 2] [2] [#pos](x1) = [0] [0] [length#1](x1) = [0 0] x1 + [0] [1 0] [2] [or](x1, x2) = [0] [0] [#or](x1, x2) = [0] [0] [split#1](x1) = [1 0] x1 + [0] [1 0] [2] [split#2](x1, x2) = [1 0] x1 + [1 2] x2 + [1] [1 0] [0 2] [2] [split#3](x1, x2, x3) = [1 0] x1 + [1 2] x2 + [1 2] x3 + [2] [0 1] [0 0] [0 2] [1] [splitAt#1](x1, x2) = [0 0] x1 + [1 0] x2 + [0] [1 0] [0 0] [0] [splitAt#2](x1, x2) = [1 0] x1 + [0 0] x2 + [0] [0 0] [1 0] [1] [splitAt#3](x1, x2) = [1 0] x1 + [1 2] x2 + [1] [0 1] [0 0] [1] [zipWithAnd#1](x1, x2) = [0 1] x1 + [0] [0 1] [0] [zipWithAnd#2](x1, x2, x3) = [0 1] x3 + [1] [0 1] [1] [zipWithOr#1](x1, x2) = [0 1] x1 + [0] [0 1] [0] [zipWithOr#2](x1, x2, x3) = [0 1] x3 + [1] [0 1] [1] [#neg](x1) = [1] [1] [#pred](x1) = [1 0] x1 + [1] [0 0] [2] [#succ](x1) = [1 0] x1 + [0] [2 0] [1] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [and^#](x1, x2) = [0] [0] [#and^#](x1, x2) = [0] [0] [append^#](x1, x2) = [0] [0] [append#1^#](x1, x2) = [0] [0] [append#2^#](x1, x2) = [0] [0] [bitonicMerge^#](x1, x2) = [1 0] x1 + [0] [0 0] [0] [bitonicMerge#1^#](x1, x2, x3) = [1 0] x3 + [0] [0 0] [0] [bitonicMerge#2^#](x1, x2, x3) = [1 0] x3 + [0] [0 0] [1] [bitonicMerge#3^#](x1, x2, x3) = [2 0] x1 + [0] [0 0] [0] [div2^#](x1) = [0] [0] [length^#](x1) = [1 0] x1 + [0] [0 0] [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [0] [length#1^#](x1) = [1 0] x1 + [0] [0 0] [1] [div2#1^#](x1) = [0] [0] [bitonicMerge#4^#](x1, x2) = [0 2] x1 + [0] [0 0] [0] [splitAt^#](x1, x2) = [0 0] x2 + [0] [1 0] [1] [splitAt#1^#](x1, x2) = [0] [0] [bitonicMerge#5^#](x1, x2, x3) = [1 0] x1 + [0 1] x3 + [0] [0 0] [0 0] [0] [bitonicMerge#6^#](x1) = [0] [0] [zipWithOr^#](x1, x2) = [0] [0] [bitonicMerge#7^#](x1, x2, x3) = [1 0] x1 + [1 0] x3 + [0] [0 0] [0 0] [1] [bitonicMerge#8^#](x1) = [0] [0] [zipWithAnd^#](x1, x2) = [0] [0] [bitonicMerge#9^#](x1, x2) = [1 0] x1 + [0] [0 0] [0] [zipWithOr#1^#](x1, x2) = [0] [0] [zipWithAnd#1^#](x1, x2) = [0] [0] [bitonicSort^#](x1, x2) = [2 0] x1 + [2] [0 0] [1] [bitonicSort#1^#](x1, x2, x3) = [2 0] x3 + [2] [0 0] [0] [bitonicSort#2^#](x1, x2) = [2 0] x1 + [2] [0 0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [bitonicSort#3^#](x1, x2, x3, x4) = [2 0] x3 + [2 0] x4 + [2] [0 0] [1 0] [1] [bitonicSort#4^#](x1, x2, x3, x4) = [2 0] x3 + [1 0] x4 + [0] [0 0] [0 0] [1] [div2#2^#](x1) = [0] [0] [or^#](x1, x2) = [0] [0] [#or^#](x1, x2) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [splitAt#2^#](x1, x2) = [0 0] x2 + [0] [0 1] [1] [splitAt#3^#](x1, x2) = [0] [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [1] [zipWithOr#2^#](x1, x2, x3) = [0] [0] [#succ^#](x1) = [0] [0] [#pred^#](x1) = [0] [0] [c_1](x1) = [0] [0] [c_2](x1) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1, x2, x3) = [0] [0] [c_6](x1, x2) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1) = [0] [0] [c_9](x1) = [0] [0] [c_10](x1) = [0] [0] [c_11](x1, x2) = [0] [0] [c_12](x1) = [0] [0] [c_13](x1) = [0] [0] [c_14](x1, x2) = [0] [0] [c_15](x1) = [0] [0] [c_16](x1) = [0] [0] [c_17](x1) = [0] [0] [c_18](x1) = [0] [0] [c_19](x1) = [0] [0] [c_20](x1, x2, x3) = [0] [0] [c_21](x1) = [0] [0] [c_22](x1) = [0] [0] [c_26](x1) = [0] [0] [c_27](x1) = [0] [0] [c_29](x1, x2) = [0] [0] [c_30](x1) = [0] [0] [c_31](x1) = [0] [0] [c_32](x1) = [0] [0] [c_33](x1) = [0] [0] [c_34](x1) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [0] [c_2](x1) = [1 1] x1 + [0] [0 0] [0] [c_3](x1) = [1 0] x1 + [0] [0 0] [0] [c_4](x1) = [1 0] x1 + [0] [0 0] [0] [c_5](x1) = [1 0] x1 + [0] [0 0] [0] [c_6](x1) = [1 0] x1 + [0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_8](x1) = [1 0] x1 + [0] [0 0] [0] [c_9](x1) = [1 0] x1 + [0] [0 0] [0] [c_10](x1, x2) = [1 1] x1 + [1 1] x2 + [0] [0 0] [0 0] [0] [c_11](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_12](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_13](x1) = [2 0] x1 + [0] [0 0] [0] [c_14](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_15](x1) = [1 1] x1 + [0] [0 0] [0] [c_16](x1) = [1 0] x1 + [0] [0 0] [0] [c_17](x1) = [1 1] x1 + [0] [0 0] [0] [c_18](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [0] [0 0] [0 0] [0 0] [0] [c_19](x1) = [1 1] x1 + [0] [0 0] [0] [c_20](x1) = [1 0] x1 + [0] [0 0] [0] [c_21](x1) = [1 0] x1 + [0] [0 0] [0] [c_22](x1) = [1 0] x1 + [0] [0 0] [0] [c_23](x1) = [1 0] x1 + [0] [0 0] [0] [c_24](x1) = [1 0] x1 + [0] [0 0] [0] [c_25](x1) = [1 0] x1 + [0] [0 0] [0] [c_26](x1) = [1 1] x1 + [0] [0 0] [0] [c_27](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_28](x1) = [1 0] x1 + [0] [0 0] [0] [c_29](x1) = [1 0] x1 + [0] [0 0] [0] [c_30](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [+(@x, @y)] = [1 1] @x + [1 0] @y + [0] [2 2] [2 1] [1] >= [1 0] @x + [1 0] @y + [0] [0 1] [2 1] [1] = [#add(@x, @y)] [#add(#0(), @y)] = [1 0] @y + [0] [2 1] [3] >= [1 0] @y + [0] [0 1] [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1 0] @y + [0] [2 1] [1] >= [1 0] @y + [0] [2 0] [1] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1 0] @y + [0] [2 1] [1] >= [1 0] @y + [0] [2 0] [1] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1 0] @y + [1] [2 1] [2] >= [1 0] @y + [1] [0 0] [2] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1 0] @y + [1] [2 1] [2] >= [1 0] @y + [1] [0 0] [2] = [#pred(#add(#pos(#s(@x)), @y))] [and(@x, @y)] = [0] [0] >= [0] [0] = [#and(@x, @y)] [#and(#false(), #false())] = [0] [0] >= [0] [0] = [#false()] [#and(#false(), #true())] = [0] [0] >= [0] [0] = [#false()] [#and(#true(), #false())] = [0] [0] >= [0] [0] = [#false()] [#and(#true(), #true())] = [0] [0] >= [0] [0] = [#true()] [append(@l, @ys)] = [1 0] @l + [1 0] @ys + [0] [0 2] [0 1] [2] >= [1 0] @l + [1 0] @ys + [0] [0 2] [0 1] [2] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [1 2] @x + [1 0] @xs + [1 0] @ys + [1] [0 0] [0 2] [0 1] [4] >= [1 2] @x + [1 0] @xs + [1 0] @ys + [1] [0 0] [0 2] [0 1] [4] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [1 0] @ys + [0] [0 1] [2] >= [1 0] @ys + [0] [0 1] [0] = [@ys] [append#2(@l', @x)] = [1 0] @l' + [1 2] @x + [1] [0 1] [0 0] [2] >= [1 0] @l' + [1 2] @x + [1] [0 1] [0 0] [1] = [::(@x, @l')] [bitonicMerge#10(#false(), @hi, @low)] = [1 0] @hi + [1 0] @low + [0] [1 1] [1 2] [0] >= [1 0] @hi + [1 0] @low + [0] [0 0] [0 1] [0] = [tuple#2(@low, @hi)] [bitonicMerge#10(#true(), @hi, @low)] = [1 0] @hi + [1 0] @low + [0] [1 1] [1 2] [0] >= [1 0] @hi + [1 0] @low + [0] [0 1] [0 0] [0] = [tuple#2(@hi, @low)] [length(@l)] = [0 0] @l + [0] [1 0] [2] >= [0 0] @l + [0] [1 0] [2] = [length#1(@l)] [div2(@n)] = [0 0] @n + [0] [0 2] [0] >= [0 0] @n + [0] [0 2] [0] = [div2#1(@n)] [splitAt(@n, @l)] = [1 0] @l + [0 0] @n + [0] [0 0] [1 0] [0] >= [1 0] @l + [0 0] @n + [0] [0 0] [1 0] [0] = [splitAt#1(@n, @l)] [bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0 1] @zipWithOr@1 + [0] [0 1] [0] >= [0 1] @zipWithOr@1 + [0] [0 1] [0] = [zipWithOr(@zipWithOr@1, @zipWithOr@2)] [bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0 1] @zipWithAnd@3 + [0] [0 1] [0] >= [0 1] @zipWithAnd@3 + [0] [0 1] [0] = [zipWithAnd(@zipWithAnd@3, @zipWithAnd@4)] [zipWithOr(@l1, @l2)] = [0 1] @l1 + [0] [0 1] [0] >= [0 1] @l1 + [0] [0 1] [0] = [zipWithOr#1(@l1, @l2)] [zipWithAnd(@l1, @l2)] = [0 1] @l1 + [0] [0 1] [0] >= [0 1] @l1 + [0] [0 1] [0] = [zipWithAnd#1(@l1, @l2)] [split(@l)] = [1 0] @l + [0] [1 0] [2] >= [1 0] @l + [0] [1 0] [2] = [split#1(@l)] [div2#1(#0())] = [0] [4] >= [0] [2] = [#0()] [div2#1(#s(@n))] = [0 0] @n + [0] [0 2] [2] >= [0 0] @n + [0] [0 2] [2] = [div2#2(@n)] [div2#2(#0())] = [0] [6] >= [0] [2] = [#0()] [div2#2(#s(@n))] = [0 0] @n + [0] [0 2] [4] >= [0 0] @n + [0] [0 2] [1] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [0 0] @x + [0 0] @xs + [0] [1 2] [1 0] [3] >= [0 0] @xs + [0] [1 0] [3] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [0] [2] >= [0] [2] = [#0()] [or(@x, @y)] = [0] [0] >= [0] [0] = [#or(@x, @y)] [#or(#false(), #false())] = [0] [0] >= [0] [0] = [#false()] [#or(#false(), #true())] = [0] [0] >= [0] [0] = [#true()] [#or(#true(), #false())] = [0] [0] >= [0] [0] = [#true()] [#or(#true(), #true())] = [0] [0] >= [0] [0] = [#true()] [split#1(::(@x1, @xs))] = [1 2] @x1 + [1 0] @xs + [1] [1 2] [1 0] [3] >= [1 2] @x1 + [1 0] @xs + [1] [0 2] [1 0] [2] = [split#2(@xs, @x1)] [split#1(nil())] = [0] [2] >= [0] [0] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [1 2] @x1 + [1 2] @x2 + [1 0] @xs' + [2] [0 2] [1 2] [1 0] [3] >= [1 2] @x1 + [1 2] @x2 + [1 0] @xs' + [2] [0 0] [0 2] [1 0] [3] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [1 2] @x1 + [1] [0 2] [2] > [0] [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [1 0] @l1 + [1 0] @l2 + [1 2] @x1 + [1 2] @x2 + [2] [0 1] [0 0] [0 0] [0 2] [1] >= [1 0] @l1 + [1 0] @l2 + [1 2] @x1 + [1 2] @x2 + [2] [0 1] [0 0] [0 0] [0 0] [1] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [splitAt#1(#0(), @l)] = [1 0] @l + [0] [0 0] [0] >= [1 0] @l + [0] [0 0] [0] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [1 0] @l + [0 0] @n' + [0] [0 0] [1 0] [2] >= [1 0] @l + [0 0] @n' + [0] [0 0] [1 0] [1] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [0 0] @n' + [1 2] @x + [1 0] @xs + [1] [1 0] [0 0] [0 0] [1] >= [0 0] @n' + [1 2] @x + [1 0] @xs + [1] [1 0] [0 0] [0 0] [1] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [0 0] @n' + [0] [1 0] [1] >= [0] [0] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [1 0] @l1 + [1 0] @l2 + [1 2] @x + [1] [0 1] [0 0] [0 0] [1] >= [1 0] @l1 + [1 0] @l2 + [1 2] @x + [1] [0 1] [0 0] [0 0] [1] = [tuple#2(::(@x, @l1), @l2)] [zipWithAnd#1(::(@x, @xs), @l2)] = [0 1] @xs + [1] [0 1] [1] >= [0 1] @xs + [1] [0 1] [1] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [0] [0] >= [0] [0] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [0 1] @xs + [1] [0 1] [1] >= [0 1] @xs + [1] [0 1] [1] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [0 1] @xs + [1] [0 1] [1] > [0] [0] = [nil()] [zipWithOr#1(::(@x, @xs), @l2)] = [0 1] @xs + [1] [0 1] [1] >= [0 1] @xs + [1] [0 1] [1] = [zipWithOr#2(@l2, @x, @xs)] [zipWithOr#1(nil(), @l2)] = [0] [0] >= [0] [0] = [nil()] [zipWithOr#2(::(@y, @ys), @x, @xs)] = [0 1] @xs + [1] [0 1] [1] >= [0 1] @xs + [1] [0 1] [1] = [::(or(@x, @y), zipWithOr(@xs, @ys))] [zipWithOr#2(nil(), @x, @xs)] = [0 1] @xs + [1] [0 1] [1] > [0] [0] = [nil()] [#pred(#0())] = [1] [2] >= [1] [1] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [1] [2] > [0] [2] = [#0()] [#pred(#pos(#s(#s(@x))))] = [1] [2] > [0] [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [2] [2] > [1] [1] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] [1] >= [0] [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] [1] >= [0] [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [1] [3] > [0] [2] = [#0()] [#succ(#neg(#s(#s(@x))))] = [1] [3] >= [1] [1] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] [0] >= [0] [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] [0] >= [0] [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [1 0] @l + [0] [0 0] [0] >= [1 0] @l + [0] [0 0] [0] = [c_8(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [1 0] @l + [0] [0 0] [0] >= [1 0] @l + [0] [0 0] [0] = [c_9(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [1 0] @l + [0] [0 0] [1] >= [1 0] @l + [0] [0 0] [0] = [c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l))] [bitonicMerge#3^#(@h, @direction, @l)] = [2 0] @h + [0] [0 0] [0] >= [2 0] @h + [0] [0 0] [0] = [c_11(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l))] [length^#(@l)] = [1 0] @l + [0] [0 0] [0] >= [1 0] @l + [0] [0 0] [0] = [c_3(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [1 2] @x + [1 0] @xs + [1] [0 0] [0 0] [1] > [1 0] @xs + [0] [0 0] [0] = [c_4(length^#(@xs))] [bitonicMerge#4^#(@s, @direction)] = [0 2] @s + [0] [0 0] [0] >= [0 2] @s + [0] [0 0] [0] = [c_12(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s))] [splitAt^#(@n, @l)] = [0 0] @l + [0] [1 0] [1] >= [0] [0] = [c_5(splitAt#1^#(@n, @l))] [splitAt#1^#(#s(@n'), @l)] = [0] [0] >= [0] [0] = [c_13(splitAt#2^#(@l, @n'))] [bitonicMerge#5^#(@hi, @direction, @s)] = [1 0] @hi + [0 1] @s + [0] [0 0] [0 0] [0] >= [1 0] @hi + [0 1] @s + [0] [0 0] [0 0] [0] = [c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s))] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0] [0] >= [0] [0] = [c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [0] [0] >= [0] [0] = [c_6(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [1 0] @hi + [1 0] @low + [0] [0 0] [0 0] [1] >= [1 0] @hi + [1 0] @low + [0] [0 0] [0 0] [0] = [c_16(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0] [0] >= [0] [0] = [c_17(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [0] [0] >= [0] [0] = [c_7(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1 0] @hi + [1 0] @low + [0] [0 0] [0 0] [0] >= [1 0] @hi + [1 0] @low + [0] [0 0] [0 0] [0] = [c_18(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [zipWithOr#1^#(::(@x, @xs), @l2)] = [0] [0] >= [0] [0] = [c_19(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [0] [0] >= [0] [0] = [c_20(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [2 0] @l + [2] [0 0] [1] >= [2 0] @l + [2] [0 0] [0] = [c_21(bitonicSort#1^#(@l, @dir, @l))] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [2 0] @l + [2] [0 0] [0] >= [2 0] @l + [2] [0 0] [0] = [c_22(bitonicSort#2^#(split(@l), @dir))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [2 0] @l1 + [2 0] @l2 + [2] [0 0] [0 0] [0] >= [2 0] @l1 + [2] [0 0] [0] = [c_23(bitonicSort^#(@l1, #true()))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [2 0] @l1 + [2 0] @l2 + [2] [0 0] [0 0] [0] >= [2 0] @l1 + [2 0] @l2 + [2] [0 0] [0 0] [0] = [c_24(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [2 0] @l1 + [2 0] @l2 + [2] [0 0] [1 0] [1] >= [2 0] @l2 + [2] [0 0] [0] = [c_25(bitonicSort^#(@l2, #false()))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [2 0] @l1 + [2 0] @l2 + [2] [0 0] [1 0] [1] > [2 0] @l1 + [1 0] @l2 + [1] [0 0] [0 0] [0] = [c_26(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2))] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [2 0] @l1 + [1 0] @l2 + [0] [0 0] [0 0] [1] >= [1 0] @l1 + [1 0] @l2 + [0] [0 0] [0 0] [0] = [c_27(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2))] [splitAt#2^#(::(@x, @xs), @n')] = [0 0] @n' + [0] [0 1] [1] >= [0] [0] = [c_28(splitAt^#(@n', @xs))] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [0] [1] >= [0] [0] = [c_29(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [0] [0] >= [0] [0] = [c_30(zipWithOr^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , 2: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , 3: length^#(@l) -> c_3(length#1^#(@l)) , 4: length#1^#(::(@x, @xs)) -> c_4(length^#(@xs)) , 5: splitAt^#(@n, @l) -> c_5(splitAt#1^#(@n, @l)) , 6: zipWithOr^#(@l1, @l2) -> c_6(zipWithOr#1^#(@l1, @l2)) , 7: zipWithAnd^#(@l1, @l2) -> c_7(zipWithAnd#1^#(@l1, @l2)) , 8: bitonicMerge^#(@l, @direction) -> c_8(bitonicMerge#1^#(@l, @direction, @l)) , 9: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_9(bitonicMerge#2^#(@xs, @direction, @l)) , 10: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l)) , 11: bitonicMerge#3^#(@h, @direction, @l) -> c_11(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , 12: bitonicMerge#4^#(@s, @direction) -> c_12(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , 13: splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , 14: bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , 15: bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , 16: bitonicMerge#7^#(@low, @direction, @hi) -> c_16(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , 17: bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_17(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , 18: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_18(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , 19: zipWithOr#1^#(::(@x, @xs), @l2) -> c_19(zipWithOr#2^#(@l2, @x, @xs)) , 20: zipWithAnd#1^#(::(@x, @xs), @l2) -> c_20(zipWithAnd#2^#(@l2, @x, @xs)) , 21: bitonicSort^#(@l, @dir) -> c_21(bitonicSort#1^#(@l, @dir, @l)) , 22: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_22(bitonicSort#2^#(split(@l), @dir)) , 23: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_23(bitonicSort^#(@l1, #true())) , 24: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_24(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , 25: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_25(bitonicSort^#(@l2, #false())) , 26: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_26(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) , 27: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_27(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , 28: splitAt#2^#(::(@x, @xs), @n') -> c_28(splitAt^#(@n', @xs)) , 29: zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_29(zipWithAnd^#(@xs, @ys)) , 30: zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_30(zipWithOr^#(@xs, @ys)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {4,26}. These cover all (indirect) predecessors of dependency pairs {4,26,27}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , length^#(@l) -> c_3(length#1^#(@l)) , splitAt^#(@n, @l) -> c_5(splitAt#1^#(@n, @l)) , zipWithOr^#(@l1, @l2) -> c_6(zipWithOr#1^#(@l1, @l2)) , zipWithAnd^#(@l1, @l2) -> c_7(zipWithAnd#1^#(@l1, @l2)) } Weak DPs: { bitonicMerge^#(@l, @direction) -> c_8(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_9(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_11(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , length#1^#(::(@x, @xs)) -> c_4(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_12(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_16(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_17(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_18(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_19(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_20(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_21(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_22(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_23(bitonicSort^#(@l1, #true())) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_24(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_25(bitonicSort^#(@l2, #false())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_26(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_27(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , splitAt#2^#(::(@x, @xs), @n') -> c_28(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_29(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_30(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 9: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l)) , 13: splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , 27: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_27(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) } Trs: { #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , bitonicMerge#2(nil(), @direction, @l) -> @l , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1, 2}, Uargs(c_11) = {1, 2}, Uargs(c_12) = {1, 2}, Uargs(c_13) = {1}, Uargs(c_14) = {1, 2}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1, 2, 3}, Uargs(c_19) = {1}, Uargs(c_20) = {1}, Uargs(c_21) = {1}, Uargs(c_22) = {1}, Uargs(c_23) = {1}, Uargs(c_24) = {1}, Uargs(c_25) = {1}, Uargs(c_26) = {1}, Uargs(c_27) = {1, 2}, Uargs(c_28) = {1}, Uargs(c_29) = {1}, Uargs(c_30) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [+](x1, x2) = [2 1] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [#add](x1, x2) = [2 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [and](x1, x2) = [0] [0] [#and](x1, x2) = [0] [0] [append](x1, x2) = [2 0] x1 + [1 2] x2 + [0] [0 2] [0 1] [0] [append#1](x1, x2) = [2 0] x1 + [1 2] x2 + [0] [0 2] [0 1] [0] [::](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 1] [1] [append#2](x1, x2) = [1 0] x1 + [2 1] x2 + [0] [0 1] [0 0] [1] [nil] = [0] [0] [bitonicMerge](x1, x2) = [1 1] x1 + [0] [2 1] [0] [bitonicMerge#1](x1, x2, x3) = [2 0] x2 + [1 0] x3 + [0] [2 2] [0 0] [0] [bitonicMerge#2](x1, x2, x3) = [0 1] x1 + [2 0] x3 + [1] [0 0] [0 2] [0] [#false] = [0] [0] [bitonicMerge#10](x1, x2, x3) = [1 1] x2 + [1 1] x3 + [0] [0 1] [0 2] [0] [tuple#2](x1, x2) = [0 1] x1 + [0 1] x2 + [0] [0 1] [0 0] [0] [#true] = [0] [0] [length](x1) = [0] [1] [div2](x1) = [2 0] x1 + [0] [1 0] [0] [bitonicMerge#3](x1, x2, x3) = [2 0] x1 + [2 0] x2 + [2] [0 0] [2 2] [0] [splitAt](x1, x2) = [0 0] x1 + [2 1] x2 + [2] [0 1] [0 0] [0] [bitonicMerge#4](x1, x2) = [2 0] x2 + [2] [2 0] [0] [bitonicMerge#6](x1) = [0 0] x1 + [0] [0 1] [1] [bitonicMerge#5](x1, x2, x3) = [2 0] x1 + [0 0] x3 + [2] [0 2] [0 2] [2] [bitonicMerge#8](x1) = [0 0] x1 + [0] [0 1] [0] [bitonicMerge#7](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [2 2] x3 + [1] [1 0] [2 0] [2 2] [0] [zipWithOr](x1, x2) = [0 0] x1 + [0] [0 1] [1] [bitonicMerge#9](x1, x2) = [0 2] x1 + [2] [0 2] [0] [zipWithAnd](x1, x2) = [0 0] x1 + [0] [0 1] [0] [bitonicSort](x1, x2) = [0 1] x1 + [0] [0 1] [0] [bitonicSort#1](x1, x2, x3) = [2 0] x2 + [0] [2 2] [0] [split](x1) = [0 1] x1 + [0] [0 1] [0] [bitonicSort#2](x1, x2) = [2 0] x2 + [0] [2 2] [0] [bitonicSort#3](x1, x2, x3, x4) = [1 0] x2 + [0] [0 0] [0] [bitonicSort#4](x1, x2, x3, x4) = [0 0] x3 + [0] [0 2] [0] [div2#1](x1) = [2 0] x1 + [0] [1 0] [0] [#0] = [0] [0] [#s](x1) = [1 0] x1 + [1] [0 1] [2] [div2#2](x1) = [2 0] x1 + [2] [1 0] [0] [#pos](x1) = [0] [0] [length#1](x1) = [0] [1] [or](x1, x2) = [0] [0] [#or](x1, x2) = [0] [0] [split#1](x1) = [0 1] x1 + [0] [0 1] [0] [split#2](x1, x2) = [0 1] x1 + [1] [0 1] [1] [split#3](x1, x2, x3) = [1 0] x1 + [2] [0 1] [2] [splitAt#1](x1, x2) = [0 0] x1 + [2 1] x2 + [2] [0 1] [0 0] [0] [splitAt#2](x1, x2) = [2 1] x1 + [0 0] x2 + [2] [0 0] [0 1] [2] [splitAt#3](x1, x2) = [1 0] x1 + [1] [0 1] [2] [zipWithAnd#1](x1, x2) = [0 0] x1 + [0] [0 1] [0] [zipWithAnd#2](x1, x2, x3) = [0 0] x3 + [0] [0 1] [1] [zipWithOr#1](x1, x2) = [0 0] x1 + [0] [0 1] [1] [zipWithOr#2](x1, x2, x3) = [0 0] x3 + [0] [0 1] [2] [#neg](x1) = [1 0] x1 + [0] [0 0] [2] [#pred](x1) = [1 0] x1 + [2] [0 0] [2] [#succ](x1) = [1 0] x1 + [0] [0 1] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [and^#](x1, x2) = [0] [0] [#and^#](x1, x2) = [0] [0] [append^#](x1, x2) = [0] [1] [append#1^#](x1, x2) = [0] [0] [append#2^#](x1, x2) = [0] [0] [bitonicMerge^#](x1, x2) = [0 1] x1 + [0] [0 0] [0] [bitonicMerge#1^#](x1, x2, x3) = [0 1] x1 + [0] [0 0] [0] [bitonicMerge#2^#](x1, x2, x3) = [0 1] x1 + [1] [0 0] [1] [bitonicMerge#3^#](x1, x2, x3) = [2 2] x1 + [1] [0 1] [0] [div2^#](x1) = [0] [0] [length^#](x1) = [0] [1] [bitonicMerge#10^#](x1, x2, x3) = [0] [0] [length#1^#](x1) = [0] [0] [div2#1^#](x1) = [0] [0] [bitonicMerge#4^#](x1, x2) = [0 2] x1 + [1] [0 0] [0] [splitAt^#](x1, x2) = [1 0] x1 + [0] [1 0] [0] [splitAt#1^#](x1, x2) = [1 0] x1 + [0] [0 0] [0] [bitonicMerge#5^#](x1, x2, x3) = [1 1] x1 + [0 1] x3 + [0] [0 0] [0 0] [0] [bitonicMerge#6^#](x1) = [0] [0] [zipWithOr^#](x1, x2) = [0] [0] [bitonicMerge#7^#](x1, x2, x3) = [2 1] x1 + [1 1] x3 + [0] [0 0] [0 0] [0] [bitonicMerge#8^#](x1) = [0] [0] [zipWithAnd^#](x1, x2) = [0] [0] [bitonicMerge#9^#](x1, x2) = [1 0] x1 + [0] [1 1] [0] [zipWithOr#1^#](x1, x2) = [0] [0] [zipWithAnd#1^#](x1, x2) = [0] [1] [bitonicSort^#](x1, x2) = [0 2] x1 + [1] [0 1] [0] [bitonicSort#1^#](x1, x2, x3) = [0 2] x3 + [1] [0 0] [0] [bitonicSort#2^#](x1, x2) = [2 0] x1 + [1] [0 0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [bitonicSort#3^#](x1, x2, x3, x4) = [0 2] x3 + [0 2] x4 + [1] [0 0] [0 0] [0] [bitonicSort#4^#](x1, x2, x3, x4) = [0 2] x3 + [0 2] x4 + [1] [0 0] [0 0] [0] [div2#2^#](x1) = [0] [0] [or^#](x1, x2) = [0] [0] [#or^#](x1, x2) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [splitAt#2^#](x1, x2) = [1 0] x2 + [0] [0 1] [1] [splitAt#3^#](x1, x2) = [0] [0] [zipWithAnd#2^#](x1, x2, x3) = [0 0] x3 + [0] [0 1] [1] [zipWithOr#2^#](x1, x2, x3) = [0 0] x3 + [0] [1 0] [0] [#succ^#](x1) = [0] [0] [#pred^#](x1) = [0] [0] [c_1](x1) = [0] [0] [c_2](x1) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1, x2, x3) = [0] [0] [c_6](x1, x2) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1) = [0] [0] [c_9](x1) = [0] [0] [c_10](x1) = [0] [0] [c_11](x1, x2) = [0] [0] [c_12](x1) = [0] [0] [c_13](x1) = [0] [0] [c_14](x1, x2) = [0] [0] [c_15](x1) = [0] [0] [c_16](x1) = [0] [0] [c_17](x1) = [0] [0] [c_18](x1) = [0] [0] [c_19](x1) = [0] [0] [c_20](x1, x2, x3) = [0] [0] [c_21](x1) = [0] [0] [c_22](x1) = [0] [0] [c_26](x1) = [0] [0] [c_27](x1) = [0] [0] [c_29](x1, x2) = [0] [0] [c_30](x1) = [0] [0] [c_31](x1) = [0] [0] [c_32](x1) = [0] [0] [c_33](x1) = [0] [0] [c_34](x1) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [0] [c_2](x1) = [1 0] x1 + [0] [0 0] [0] [c_3](x1) = [1 1] x1 + [0] [0 0] [0] [c_4](x1) = [1 0] x1 + [0] [0 0] [0] [c_5](x1) = [1 0] x1 + [0] [0 0] [0] [c_6](x1) = [1 0] x1 + [0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_8](x1) = [1 0] x1 + [0] [0 0] [0] [c_9](x1) = [1 0] x1 + [0] [0 0] [0] [c_10](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_11](x1, x2) = [1 0] x1 + [1 1] x2 + [0] [0 0] [0 0] [0] [c_12](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_13](x1) = [1 0] x1 + [0] [0 0] [0] [c_14](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_15](x1) = [2 1] x1 + [0] [0 0] [0] [c_16](x1) = [1 0] x1 + [0] [0 0] [0] [c_17](x1) = [1 1] x1 + [0] [0 0] [0] [c_18](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 0] x3 + [0] [0 0] [0 0] [0 0] [0] [c_19](x1) = [2 0] x1 + [0] [0 0] [0] [c_20](x1) = [1 0] x1 + [0] [0 0] [0] [c_21](x1) = [1 0] x1 + [0] [0 0] [0] [c_22](x1) = [1 0] x1 + [0] [0 0] [0] [c_23](x1) = [1 0] x1 + [0] [0 0] [0] [c_24](x1) = [1 0] x1 + [0] [0 0] [0] [c_25](x1) = [1 0] x1 + [0] [0 0] [0] [c_26](x1) = [1 0] x1 + [0] [0 0] [0] [c_27](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_28](x1) = [1 0] x1 + [0] [0 0] [0] [c_29](x1) = [1 1] x1 + [0] [0 0] [0] [c_30](x1) = [1 1] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [+(@x, @y)] = [2 1] @x + [1 0] @y + [0] [0 1] [0 1] [0] >= [2 0] @x + [1 0] @y + [0] [0 1] [0 1] [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1 0] @y + [0] [0 1] [0] >= [1 0] @y + [0] [0 1] [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1 0] @y + [0] [0 1] [0] >= [1 0] @y + [0] [0 1] [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1 0] @y + [0] [0 1] [0] >= [1 0] @y + [0] [0 1] [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1 0] @y + [2] [0 1] [2] >= [1 0] @y + [2] [0 0] [2] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [2 0] @x + [1 0] @y + [4] [0 0] [0 1] [2] > [1 0] @y + [2] [0 0] [2] = [#pred(#add(#pos(#s(@x)), @y))] [and(@x, @y)] = [0] [0] >= [0] [0] = [#and(@x, @y)] [#and(#false(), #false())] = [0] [0] >= [0] [0] = [#false()] [#and(#false(), #true())] = [0] [0] >= [0] [0] = [#false()] [#and(#true(), #false())] = [0] [0] >= [0] [0] = [#false()] [#and(#true(), #true())] = [0] [0] >= [0] [0] = [#true()] [append(@l, @ys)] = [2 0] @l + [1 2] @ys + [0] [0 2] [0 1] [0] >= [2 0] @l + [1 2] @ys + [0] [0 2] [0 1] [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [2 2] @x + [2 0] @xs + [1 2] @ys + [0] [0 0] [0 2] [0 1] [2] >= [2 1] @x + [2 0] @xs + [1 2] @ys + [0] [0 0] [0 2] [0 1] [1] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [1 2] @ys + [0] [0 1] [0] >= [1 0] @ys + [0] [0 1] [0] = [@ys] [append#2(@l', @x)] = [1 0] @l' + [2 1] @x + [0] [0 1] [0 0] [1] >= [1 0] @l' + [1 1] @x + [0] [0 1] [0 0] [1] = [::(@x, @l')] [bitonicMerge#10(#false(), @hi, @low)] = [1 1] @hi + [1 1] @low + [0] [0 1] [0 2] [0] >= [0 1] @hi + [0 1] @low + [0] [0 0] [0 1] [0] = [tuple#2(@low, @hi)] [bitonicMerge#10(#true(), @hi, @low)] = [1 1] @hi + [1 1] @low + [0] [0 1] [0 2] [0] >= [0 1] @hi + [0 1] @low + [0] [0 1] [0 0] [0] = [tuple#2(@hi, @low)] [length(@l)] = [0] [1] >= [0] [1] = [length#1(@l)] [div2(@n)] = [2 0] @n + [0] [1 0] [0] >= [2 0] @n + [0] [1 0] [0] = [div2#1(@n)] [splitAt(@n, @l)] = [2 1] @l + [0 0] @n + [2] [0 0] [0 1] [0] >= [2 1] @l + [0 0] @n + [2] [0 0] [0 1] [0] = [splitAt#1(@n, @l)] [bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0 0] @zipWithOr@1 + [0] [0 1] [1] >= [0 0] @zipWithOr@1 + [0] [0 1] [1] = [zipWithOr(@zipWithOr@1, @zipWithOr@2)] [bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0 0] @zipWithAnd@3 + [0] [0 1] [0] >= [0 0] @zipWithAnd@3 + [0] [0 1] [0] = [zipWithAnd(@zipWithAnd@3, @zipWithAnd@4)] [zipWithOr(@l1, @l2)] = [0 0] @l1 + [0] [0 1] [1] >= [0 0] @l1 + [0] [0 1] [1] = [zipWithOr#1(@l1, @l2)] [zipWithAnd(@l1, @l2)] = [0 0] @l1 + [0] [0 1] [0] >= [0 0] @l1 + [0] [0 1] [0] = [zipWithAnd#1(@l1, @l2)] [split(@l)] = [0 1] @l + [0] [0 1] [0] >= [0 1] @l + [0] [0 1] [0] = [split#1(@l)] [div2#1(#0())] = [0] [0] >= [0] [0] = [#0()] [div2#1(#s(@n))] = [2 0] @n + [2] [1 0] [1] >= [2 0] @n + [2] [1 0] [0] = [div2#2(@n)] [div2#2(#0())] = [2] [0] > [0] [0] = [#0()] [div2#2(#s(@n))] = [2 0] @n + [4] [1 0] [1] > [2 0] @n + [0] [1 0] [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [0] [1] >= [0] [1] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [0] [1] >= [0] [0] = [#0()] [or(@x, @y)] = [0] [0] >= [0] [0] = [#or(@x, @y)] [#or(#false(), #false())] = [0] [0] >= [0] [0] = [#false()] [#or(#false(), #true())] = [0] [0] >= [0] [0] = [#true()] [#or(#true(), #false())] = [0] [0] >= [0] [0] = [#true()] [#or(#true(), #true())] = [0] [0] >= [0] [0] = [#true()] [split#1(::(@x1, @xs))] = [0 1] @xs + [1] [0 1] [1] >= [0 1] @xs + [1] [0 1] [1] = [split#2(@xs, @x1)] [split#1(nil())] = [0] [0] >= [0] [0] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [0 1] @xs' + [2] [0 1] [2] >= [0 1] @xs' + [2] [0 1] [2] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [1] [1] > [0] [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [0 1] @l1 + [0 1] @l2 + [2] [0 1] [0 0] [2] >= [0 1] @l1 + [0 1] @l2 + [2] [0 1] [0 0] [1] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [splitAt#1(#0(), @l)] = [2 1] @l + [2] [0 0] [0] > [0 1] @l + [0] [0 0] [0] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [2 1] @l + [0 0] @n' + [2] [0 0] [0 1] [2] >= [2 1] @l + [0 0] @n' + [2] [0 0] [0 1] [2] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [0 0] @n' + [2 2] @x + [2 1] @xs + [3] [0 1] [0 0] [0 0] [2] >= [0 0] @n' + [2 1] @xs + [3] [0 1] [0 0] [2] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [0 0] @n' + [2] [0 1] [2] > [0] [0] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [0 1] @l1 + [0 1] @l2 + [1] [0 1] [0 0] [2] >= [0 1] @l1 + [0 1] @l2 + [1] [0 1] [0 0] [1] = [tuple#2(::(@x, @l1), @l2)] [zipWithAnd#1(::(@x, @xs), @l2)] = [0 0] @xs + [0] [0 1] [1] >= [0 0] @xs + [0] [0 1] [1] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [0] [0] >= [0] [0] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [0 0] @xs + [0] [0 1] [1] >= [0 0] @xs + [0] [0 1] [1] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [0 0] @xs + [0] [0 1] [1] >= [0] [0] = [nil()] [zipWithOr#1(::(@x, @xs), @l2)] = [0 0] @xs + [0] [0 1] [2] >= [0 0] @xs + [0] [0 1] [2] = [zipWithOr#2(@l2, @x, @xs)] [zipWithOr#1(nil(), @l2)] = [0] [1] >= [0] [0] = [nil()] [zipWithOr#2(::(@y, @ys), @x, @xs)] = [0 0] @xs + [0] [0 1] [2] >= [0 0] @xs + [0] [0 1] [2] = [::(or(@x, @y), zipWithOr(@xs, @ys))] [zipWithOr#2(nil(), @x, @xs)] = [0 0] @xs + [0] [0 1] [2] >= [0] [0] = [nil()] [#pred(#0())] = [2] [2] > [1] [2] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [2] [2] > [0] [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [2] [2] > [0] [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [1 0] @x + [3] [0 0] [2] > [1 0] @x + [2] [0 0] [2] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] [0] >= [0] [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] [0] >= [0] [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [1] [2] > [0] [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [1 0] @x + [2] [0 0] [2] > [1 0] @x + [1] [0 0] [2] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] [1] >= [0] [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] [0] >= [0] [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [0 1] @l + [0] [0 0] [0] >= [0 1] @l + [0] [0 0] [0] = [c_8(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [0 1] @xs + [1] [0 0] [0] >= [0 1] @xs + [1] [0 0] [0] = [c_9(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [0 1] @ys + [2] [0 0] [1] > [1] [0] = [c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l))] [bitonicMerge#3^#(@h, @direction, @l)] = [2 2] @h + [1] [0 1] [0] >= [2 2] @h + [1] [0 0] [0] = [c_11(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l))] [length^#(@l)] = [0] [1] >= [0] [0] = [c_3(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] [0] >= [0] [0] = [c_4(length^#(@xs))] [bitonicMerge#4^#(@s, @direction)] = [0 2] @s + [1] [0 0] [0] >= [0 2] @s + [1] [0 0] [0] = [c_12(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s))] [splitAt^#(@n, @l)] = [1 0] @n + [0] [1 0] [0] >= [1 0] @n + [0] [0 0] [0] = [c_5(splitAt#1^#(@n, @l))] [splitAt#1^#(#s(@n'), @l)] = [1 0] @n' + [1] [0 0] [0] > [1 0] @n' + [0] [0 0] [0] = [c_13(splitAt#2^#(@l, @n'))] [bitonicMerge#5^#(@hi, @direction, @s)] = [1 1] @hi + [0 1] @s + [0] [0 0] [0 0] [0] >= [1 1] @hi + [0 1] @s + [0] [0 0] [0 0] [0] = [c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s))] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0] [0] >= [0] [0] = [c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [0] [0] >= [0] [0] = [c_6(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [1 1] @hi + [2 1] @low + [0] [0 0] [0 0] [0] >= [1 1] @hi + [1 1] @low + [0] [0 0] [0 0] [0] = [c_16(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0] [0] >= [0] [0] = [c_17(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [0] [0] >= [0] [0] = [c_7(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [0 1] @hi + [0 1] @low + [0] [0 2] [0 1] [0] >= [0 1] @hi + [0 1] @low + [0] [0 0] [0 0] [0] = [c_18(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [zipWithOr#1^#(::(@x, @xs), @l2)] = [0] [0] >= [0] [0] = [c_19(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [0] [1] >= [0] [0] = [c_20(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [0 2] @l + [1] [0 1] [0] >= [0 2] @l + [1] [0 0] [0] = [c_21(bitonicSort#1^#(@l, @dir, @l))] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [0 2] @l + [1] [0 0] [0] >= [0 2] @l + [1] [0 0] [0] = [c_22(bitonicSort#2^#(split(@l), @dir))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [0 2] @l1 + [0 2] @l2 + [1] [0 0] [0 0] [0] >= [0 2] @l1 + [1] [0 0] [0] = [c_23(bitonicSort^#(@l1, #true()))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [0 2] @l1 + [0 2] @l2 + [1] [0 0] [0 0] [0] >= [0 2] @l1 + [0 2] @l2 + [1] [0 0] [0 0] [0] = [c_24(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [0 2] @l1 + [0 2] @l2 + [1] [0 0] [0 0] [0] >= [0 2] @l2 + [1] [0 0] [0] = [c_25(bitonicSort^#(@l2, #false()))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [0 2] @l1 + [0 2] @l2 + [1] [0 0] [0 0] [0] >= [0 2] @l1 + [0 2] @l2 + [1] [0 0] [0 0] [0] = [c_26(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2))] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [0 2] @l1 + [0 2] @l2 + [1] [0 0] [0 0] [0] > [0 2] @l1 + [0 1] @l2 + [0] [0 0] [0 0] [0] = [c_27(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2))] [splitAt#2^#(::(@x, @xs), @n')] = [1 0] @n' + [0] [0 1] [1] >= [1 0] @n' + [0] [0 0] [0] = [c_28(splitAt^#(@n', @xs))] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [0 0] @xs + [0] [0 1] [1] >= [0] [0] = [c_29(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [0 0] @xs + [0] [1 0] [0] >= [0] [0] = [c_30(zipWithOr^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , 2: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , 3: length^#(@l) -> c_3(length#1^#(@l)) , 4: splitAt^#(@n, @l) -> c_5(splitAt#1^#(@n, @l)) , 5: zipWithOr^#(@l1, @l2) -> c_6(zipWithOr#1^#(@l1, @l2)) , 6: zipWithAnd^#(@l1, @l2) -> c_7(zipWithAnd#1^#(@l1, @l2)) , 7: bitonicMerge^#(@l, @direction) -> c_8(bitonicMerge#1^#(@l, @direction, @l)) , 8: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_9(bitonicMerge#2^#(@xs, @direction, @l)) , 9: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l)) , 10: bitonicMerge#3^#(@h, @direction, @l) -> c_11(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , 11: length#1^#(::(@x, @xs)) -> c_4(length^#(@xs)) , 12: bitonicMerge#4^#(@s, @direction) -> c_12(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , 13: splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , 14: bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , 15: bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , 16: bitonicMerge#7^#(@low, @direction, @hi) -> c_16(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , 17: bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_17(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , 18: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_18(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , 19: zipWithOr#1^#(::(@x, @xs), @l2) -> c_19(zipWithOr#2^#(@l2, @x, @xs)) , 20: zipWithAnd#1^#(::(@x, @xs), @l2) -> c_20(zipWithAnd#2^#(@l2, @x, @xs)) , 21: bitonicSort^#(@l, @dir) -> c_21(bitonicSort#1^#(@l, @dir, @l)) , 22: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_22(bitonicSort#2^#(split(@l), @dir)) , 23: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_23(bitonicSort^#(@l1, #true())) , 24: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_24(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , 25: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_25(bitonicSort^#(@l2, #false())) , 26: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_26(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) , 27: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_27(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , 28: splitAt#2^#(::(@x, @xs), @n') -> c_28(splitAt^#(@n', @xs)) , 29: zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_29(zipWithAnd^#(@xs, @ys)) , 30: zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_30(zipWithOr^#(@xs, @ys)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {9,13,27}. These cover all (indirect) predecessors of dependency pairs {4,7,8,9,10,12,13,14,15,16,17,18,27,28}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , length^#(@l) -> c_3(length#1^#(@l)) , zipWithOr^#(@l1, @l2) -> c_6(zipWithOr#1^#(@l1, @l2)) , zipWithAnd^#(@l1, @l2) -> c_7(zipWithAnd#1^#(@l1, @l2)) } Weak DPs: { bitonicMerge^#(@l, @direction) -> c_8(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_9(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_11(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , length#1^#(::(@x, @xs)) -> c_4(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_12(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , splitAt^#(@n, @l) -> c_5(splitAt#1^#(@n, @l)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_16(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_17(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_18(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_19(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_20(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_21(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_22(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_23(bitonicSort^#(@l1, #true())) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_24(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_25(bitonicSort^#(@l2, #false())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_26(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_27(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , splitAt#2^#(::(@x, @xs), @n') -> c_28(splitAt^#(@n', @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_29(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_30(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { splitAt^#(@n, @l) -> c_5(splitAt#1^#(@n, @l)) , splitAt#1^#(#s(@n'), @l) -> c_13(splitAt#2^#(@l, @n')) , splitAt#2^#(::(@x, @xs), @n') -> c_28(splitAt^#(@n', @xs)) } We apply the transformation 'simpDPRHS' on the sub-problem: Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , length^#(@l) -> c_3(length#1^#(@l)) , zipWithOr^#(@l1, @l2) -> c_6(zipWithOr#1^#(@l1, @l2)) , zipWithAnd^#(@l1, @l2) -> c_7(zipWithAnd#1^#(@l1, @l2)) } Weak DPs: { bitonicMerge^#(@l, @direction) -> c_8(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_9(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_10(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_11(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) , length#1^#(::(@x, @xs)) -> c_4(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_12(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_14(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_15(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_16(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_17(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_18(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_19(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_20(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_21(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_22(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_23(bitonicSort^#(@l1, #true())) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_24(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_25(bitonicSort^#(@l2, #false())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_26(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_27(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_29(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_30(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { bitonicMerge#3^#(@h, @direction, @l) -> c_11(bitonicMerge#4^#(splitAt(@h, @l), @direction), splitAt^#(@h, @l)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , length^#(@l) -> c_3(length#1^#(@l)) , zipWithOr^#(@l1, @l2) -> c_4(zipWithOr#1^#(@l1, @l2)) , zipWithAnd^#(@l1, @l2) -> c_5(zipWithAnd#1^#(@l1, @l2)) } Weak DPs: { bitonicMerge^#(@l, @direction) -> c_6(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_7(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_8(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_9(bitonicMerge#4^#(splitAt(@h, @l), @direction)) , length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_12(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_13(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_14(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_16(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_17(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_18(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_19(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_20(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_21(bitonicSort^#(@l1, #true())) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_22(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_23(bitonicSort^#(@l2, #false())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_24(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_25(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_26(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_27(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 2: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) } Trs: { split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#neg(#s(#0()))) -> #0() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1, 2}, Uargs(c_12) = {1, 2}, Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1, 2, 3}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_19) = {1}, Uargs(c_20) = {1}, Uargs(c_21) = {1}, Uargs(c_22) = {1}, Uargs(c_23) = {1}, Uargs(c_24) = {1}, Uargs(c_25) = {1, 2}, Uargs(c_26) = {1}, Uargs(c_27) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [2 0] x1 + [1 0] x2 + [0] [0 2] [0 1] [0] [#add](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 2] [0 1] [0] [and](x1, x2) = [0] [2] [#and](x1, x2) = [0] [0] [append](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [1 0] [1 1] [0] [append#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [1 0] [1 1] [0] [::](x1, x2) = [1 0] x2 + [1] [0 0] [0] [append#2](x1, x2) = [1 0] x1 + [1] [1 0] [1] [nil] = [0] [0] [bitonicMerge](x1, x2) = [1 0] x1 + [0] [0 1] [2] [bitonicMerge#1](x1, x2, x3) = [1 0] x3 + [0] [0 1] [2] [bitonicMerge#2](x1, x2, x3) = [1 0] x3 + [0] [0 1] [2] [#false] = [2] [1] [bitonicMerge#10](x1, x2, x3) = [1 1] x2 + [1 2] x3 + [0] [1 1] [1 1] [0] [tuple#2](x1, x2) = [1 0] x1 + [0 0] x2 + [0] [1 1] [1 0] [0] [#true] = [2] [1] [length](x1) = [0] [2] [div2](x1) = [0] [2] [bitonicMerge#3](x1, x2, x3) = [2 0] x1 + [1 0] x3 + [0] [2 0] [0 1] [2] [splitAt](x1, x2) = [1 0] x1 + [0 0] x2 + [0] [0 0] [1 0] [0] [bitonicMerge#4](x1, x2) = [2 0] x1 + [0] [2 0] [2] [bitonicMerge#6](x1) = [1 0] x1 + [0] [0 0] [0] [bitonicMerge#5](x1, x2, x3) = [1 1] x1 + [1 0] x3 + [0] [1 1] [1 0] [2] [bitonicMerge#8](x1) = [1 0] x1 + [0] [0 0] [0] [bitonicMerge#7](x1, x2, x3) = [1 2] x1 + [1 1] x3 + [0] [1 2] [1 1] [2] [zipWithOr](x1, x2) = [1 0] x1 + [0] [0 0] [0] [bitonicMerge#9](x1, x2) = [0 1] x1 + [0] [0 1] [2] [zipWithAnd](x1, x2) = [1 0] x1 + [0] [0 0] [0] [bitonicSort](x1, x2) = [1 0] x1 + [0] [0 1] [0] [bitonicSort#1](x1, x2, x3) = [2 0] x2 + [0] [2 2] [0] [split](x1) = [2 0] x1 + [1] [1 0] [0] [bitonicSort#2](x1, x2) = [2 0] x2 + [0] [2 2] [0] [bitonicSort#3](x1, x2, x3, x4) = [0 0] x2 + [0 0] x4 + [0] [1 0] [2 0] [0] [bitonicSort#4](x1, x2, x3, x4) = [2 0] x2 + [2 0] x3 + [0] [2 0] [0 0] [0] [div2#1](x1) = [0] [2] [#0] = [0] [2] [#s](x1) = [1 0] x1 + [1] [0 0] [0] [div2#2](x1) = [0] [2] [#pos](x1) = [0 0] x1 + [0] [0 1] [0] [length#1](x1) = [0 0] x1 + [0] [1 0] [2] [or](x1, x2) = [0] [1] [#or](x1, x2) = [0] [0] [split#1](x1) = [1 0] x1 + [1] [1 0] [0] [split#2](x1, x2) = [1 0] x1 + [1] [1 0] [1] [split#3](x1, x2, x3) = [0 1] x1 + [2] [0 1] [2] [splitAt#1](x1, x2) = [1 0] x1 + [0 0] x2 + [0] [0 0] [1 0] [0] [splitAt#2](x1, x2) = [0 0] x1 + [1 0] x2 + [1] [1 0] [0 0] [0] [splitAt#3](x1, x2) = [1 0] x1 + [1] [0 1] [1] [zipWithAnd#1](x1, x2) = [1 0] x1 + [0] [0 0] [0] [zipWithAnd#2](x1, x2, x3) = [1 0] x3 + [1] [0 0] [0] [zipWithOr#1](x1, x2) = [1 0] x1 + [0] [0 0] [0] [zipWithOr#2](x1, x2, x3) = [1 0] x3 + [1] [0 0] [0] [#neg](x1) = [0 0] x1 + [2] [1 0] [1] [#pred](x1) = [0 0] x1 + [2] [0 1] [2] [#succ](x1) = [1 0] x1 + [0] [0 1] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [and^#](x1, x2) = [0] [0] [#and^#](x1, x2) = [0] [0] [append^#](x1, x2) = [1 0] x1 + [0] [0 0] [1] [append#1^#](x1, x2) = [1 0] x1 + [0] [0 0] [0] [append#2^#](x1, x2) = [0] [0] [bitonicMerge^#](x1, x2) = [0 0] x1 + [0] [2 0] [0] [bitonicMerge#1^#](x1, x2, x3) = [0] [0] [bitonicMerge#2^#](x1, x2, x3) = [0] [1] [bitonicMerge#3^#](x1, x2, x3) = [2 0] x1 + [0] [0 0] [1] [div2^#](x1) = [0] [0] [length^#](x1) = [0] [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [0] [length#1^#](x1) = [0] [0] [div2#1^#](x1) = [0] [0] [bitonicMerge#4^#](x1, x2) = [2 0] x1 + [0] [0 1] [0] [splitAt^#](x1, x2) = [0] [0] [splitAt#1^#](x1, x2) = [0] [0] [bitonicMerge#5^#](x1, x2, x3) = [1 2] x1 + [1 0] x3 + [0] [0 0] [0 0] [0] [bitonicMerge#6^#](x1) = [0] [0] [zipWithOr^#](x1, x2) = [0 0] x1 + [0 0] x2 + [0] [1 1] [1 0] [1] [bitonicMerge#7^#](x1, x2, x3) = [1 1] x1 + [1 1] x3 + [0] [0 0] [0 0] [0] [bitonicMerge#8^#](x1) = [0] [0] [zipWithAnd^#](x1, x2) = [0] [0] [bitonicMerge#9^#](x1, x2) = [0 1] x1 + [0] [0 0] [0] [zipWithOr#1^#](x1, x2) = [0] [0] [zipWithAnd#1^#](x1, x2) = [0] [1] [bitonicSort^#](x1, x2) = [2 0] x1 + [0] [0 0] [0] [bitonicSort#1^#](x1, x2, x3) = [2 0] x3 + [0] [0 0] [0] [bitonicSort#2^#](x1, x2) = [0 2] x1 + [0] [0 0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [bitonicSort#3^#](x1, x2, x3, x4) = [1 0] x3 + [2 0] x4 + [0] [0 0] [1 1] [0] [bitonicSort#4^#](x1, x2, x3, x4) = [1 0] x3 + [0] [0 0] [0] [div2#2^#](x1) = [0] [0] [or^#](x1, x2) = [0] [0] [#or^#](x1, x2) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [splitAt#2^#](x1, x2) = [0] [0] [splitAt#3^#](x1, x2) = [0] [0] [zipWithAnd#2^#](x1, x2, x3) = [0 0] x3 + [0] [1 1] [1] [zipWithOr#2^#](x1, x2, x3) = [0 0] x3 + [0] [1 0] [1] [#succ^#](x1) = [0] [0] [#pred^#](x1) = [0] [0] [c_1](x1) = [0] [0] [c_2](x1) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1, x2, x3) = [0] [0] [c_6](x1, x2) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1) = [0] [0] [c_9](x1) = [0] [0] [c_10](x1) = [0] [0] [c_11](x1, x2) = [0] [0] [c_12](x1) = [0] [0] [c_13](x1) = [0] [0] [c_14](x1, x2) = [0] [0] [c_15](x1) = [0] [0] [c_16](x1) = [0] [0] [c_17](x1) = [0] [0] [c_18](x1) = [0] [0] [c_19](x1) = [0] [0] [c_20](x1, x2, x3) = [0] [0] [c_21](x1) = [0] [0] [c_22](x1) = [0] [0] [c_26](x1) = [0] [0] [c_27](x1) = [0] [0] [c_29](x1, x2) = [0] [0] [c_30](x1) = [0] [0] [c_31](x1) = [0] [0] [c_32](x1) = [0] [0] [c_33](x1) = [0] [0] [c_34](x1) = [0] [0] [c] = [0] [0] [c_1](x1) = [0] [0] [c_2](x1) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1) = [0] [0] [c_6](x1) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1) = [0] [0] [c_9](x1) = [0] [0] [c_10](x1, x2) = [0] [0] [c_11](x1, x2) = [0] [0] [c_12](x1, x2) = [0] [0] [c_13](x1) = [0] [0] [c_14](x1, x2) = [0] [0] [c_15](x1) = [0] [0] [c_16](x1) = [0] [0] [c_17](x1) = [0] [0] [c_18](x1, x2, x3) = [0] [0] [c_19](x1) = [0] [0] [c_20](x1) = [0] [0] [c_21](x1) = [0] [0] [c_22](x1) = [0] [0] [c_23](x1) = [0] [0] [c_24](x1) = [0] [0] [c_25](x1) = [0] [0] [c_26](x1) = [0] [0] [c_27](x1, x2) = [0] [0] [c_28](x1) = [0] [0] [c_29](x1) = [0] [0] [c_30](x1) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [0] [c_2](x1) = [1 0] x1 + [0] [0 0] [0] [c_3](x1) = [1 0] x1 + [0] [0 0] [0] [c_4](x1) = [1 0] x1 + [0] [0 0] [0] [c_5](x1) = [1 0] x1 + [0] [0 0] [0] [c_6](x1) = [1 0] x1 + [0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_8](x1, x2) = [2 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_9](x1) = [1 0] x1 + [0] [0 0] [0] [c_10](x1) = [2 1] x1 + [0] [0 0] [0] [c_11](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_12](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_13](x1) = [1 0] x1 + [0] [0 0] [0] [c_14](x1) = [1 0] x1 + [0] [0 0] [0] [c_15](x1) = [1 1] x1 + [0] [0 0] [0] [c_16](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [1 0] x3 + [0] [0 0] [0 0] [0 0] [0] [c_17](x1) = [1 0] x1 + [0] [0 0] [0] [c_18](x1) = [1 0] x1 + [0] [0 0] [0] [c_19](x1) = [1 0] x1 + [0] [0 0] [0] [c_20](x1) = [1 0] x1 + [0] [0 0] [0] [c_21](x1) = [1 0] x1 + [0] [0 0] [0] [c_22](x1) = [1 0] x1 + [0] [0 0] [0] [c_23](x1) = [1 0] x1 + [0] [0 0] [0] [c_24](x1) = [1 0] x1 + [0] [0 0] [0] [c_25](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_26](x1) = [2 0] x1 + [0] [0 0] [0] [c_27](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [+(@x, @y)] = [2 0] @x + [1 0] @y + [0] [0 2] [0 1] [0] >= [1 0] @x + [1 0] @y + [0] [0 2] [0 1] [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1 0] @y + [0] [0 1] [4] >= [1 0] @y + [0] [0 1] [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1 0] @y + [0] [0 1] [0] >= [1 0] @y + [0] [0 1] [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1 0] @y + [0] [0 1] [0] >= [1 0] @y + [0] [0 1] [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1 0] @y + [2] [0 1] [4] >= [0 0] @y + [2] [0 1] [2] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [0 0] @x + [1 0] @y + [2] [2 0] [0 1] [6] >= [0 0] @y + [2] [0 1] [2] = [#pred(#add(#pos(#s(@x)), @y))] [append(@l, @ys)] = [1 0] @l + [1 0] @ys + [0] [1 0] [1 1] [0] >= [1 0] @l + [1 0] @ys + [0] [1 0] [1 1] [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [1 0] @xs + [1 0] @ys + [1] [1 0] [1 1] [1] >= [1 0] @xs + [1 0] @ys + [1] [1 0] [1 0] [1] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [1 0] @ys + [0] [1 1] [0] >= [1 0] @ys + [0] [0 1] [0] = [@ys] [append#2(@l', @x)] = [1 0] @l' + [1] [1 0] [1] >= [1 0] @l' + [1] [0 0] [0] = [::(@x, @l')] [bitonicMerge(@l, @direction)] = [1 0] @l + [0] [0 1] [2] >= [1 0] @l + [0] [0 1] [2] = [bitonicMerge#1(@l, @direction, @l)] [bitonicMerge#1(::(@x, @xs), @direction, @l)] = [1 0] @l + [0] [0 1] [2] >= [1 0] @l + [0] [0 1] [2] = [bitonicMerge#2(@xs, @direction, @l)] [bitonicMerge#1(nil(), @direction, @l)] = [1 0] @l + [0] [0 1] [2] >= [0] [0] = [nil()] [bitonicMerge#2(::(@y, @ys), @direction, @l)] = [1 0] @l + [0] [0 1] [2] >= [1 0] @l + [0] [0 1] [2] = [bitonicMerge#3(div2(length(@l)), @direction, @l)] [bitonicMerge#2(nil(), @direction, @l)] = [1 0] @l + [0] [0 1] [2] >= [1 0] @l + [0] [0 1] [0] = [@l] [bitonicMerge#10(#false(), @hi, @low)] = [1 1] @hi + [1 2] @low + [0] [1 1] [1 1] [0] >= [0 0] @hi + [1 0] @low + [0] [1 0] [1 1] [0] = [tuple#2(@low, @hi)] [bitonicMerge#10(#true(), @hi, @low)] = [1 1] @hi + [1 2] @low + [0] [1 1] [1 1] [0] >= [1 0] @hi + [0 0] @low + [0] [1 1] [1 0] [0] = [tuple#2(@hi, @low)] [div2(@n)] = [0] [2] >= [0] [2] = [div2#1(@n)] [bitonicMerge#3(@h, @direction, @l)] = [2 0] @h + [1 0] @l + [0] [2 0] [0 1] [2] >= [2 0] @h + [0] [2 0] [2] = [bitonicMerge#4(splitAt(@h, @l), @direction)] [splitAt(@n, @l)] = [0 0] @l + [1 0] @n + [0] [1 0] [0 0] [0] >= [0 0] @l + [1 0] @n + [0] [1 0] [0 0] [0] = [splitAt#1(@n, @l)] [bitonicMerge#4(@s, @direction)] = [2 0] @s + [0] [2 0] [2] >= [2 0] @s + [0] [2 0] [2] = [bitonicMerge#5(bitonicMerge#6(@s), @direction, @s)] [bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [1 0] @zipWithOr@1 + [0] [0 0] [0] >= [1 0] @zipWithOr@1 + [0] [0 0] [0] = [zipWithOr(@zipWithOr@1, @zipWithOr@2)] [bitonicMerge#5(@hi, @direction, @s)] = [1 1] @hi + [1 0] @s + [0] [1 1] [1 0] [2] >= [1 1] @hi + [1 0] @s + [0] [1 1] [1 0] [2] = [bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi)] [bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [1 0] @zipWithAnd@3 + [0] [0 0] [0] >= [1 0] @zipWithAnd@3 + [0] [0 0] [0] = [zipWithAnd(@zipWithAnd@3, @zipWithAnd@4)] [bitonicMerge#7(@low, @direction, @hi)] = [1 1] @hi + [1 2] @low + [0] [1 1] [1 2] [2] >= [1 1] @hi + [1 1] @low + [0] [1 1] [1 1] [2] = [bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction)] [zipWithOr(@l1, @l2)] = [1 0] @l1 + [0] [0 0] [0] >= [1 0] @l1 + [0] [0 0] [0] = [zipWithOr#1(@l1, @l2)] [bitonicMerge#9(tuple#2(@hi, @low), @direction)] = [1 1] @hi + [1 0] @low + [0] [1 1] [1 0] [2] >= [1 0] @hi + [1 0] @low + [0] [1 1] [1 0] [2] = [append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction))] [zipWithAnd(@l1, @l2)] = [1 0] @l1 + [0] [0 0] [0] >= [1 0] @l1 + [0] [0 0] [0] = [zipWithAnd#1(@l1, @l2)] [split(@l)] = [2 0] @l + [1] [1 0] [0] >= [1 0] @l + [1] [1 0] [0] = [split#1(@l)] [div2#1(#0())] = [0] [2] >= [0] [2] = [#0()] [div2#1(#s(@n))] = [0] [2] >= [0] [2] = [div2#2(@n)] [div2#2(#0())] = [0] [2] >= [0] [2] = [#0()] [div2#2(#s(@n))] = [0] [2] >= [0] [2] = [+(#pos(#s(#0())), div2(@n))] [split#1(::(@x1, @xs))] = [1 0] @xs + [2] [1 0] [1] > [1 0] @xs + [1] [1 0] [1] = [split#2(@xs, @x1)] [split#1(nil())] = [1] [0] > [0] [0] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [1 0] @xs' + [2] [1 0] [2] >= [1 0] @xs' + [2] [1 0] [2] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [1] [1] > [0] [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [1 1] @l1 + [1 0] @l2 + [2] [1 1] [1 0] [2] > [1 0] @l1 + [0 0] @l2 + [1] [1 0] [1 0] [2] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [splitAt#1(#0(), @l)] = [0 0] @l + [0] [1 0] [0] >= [0 0] @l + [0] [1 0] [0] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [0 0] @l + [1 0] @n' + [1] [1 0] [0 0] [0] >= [0 0] @l + [1 0] @n' + [1] [1 0] [0 0] [0] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [1 0] @n' + [0 0] @xs + [1] [0 0] [1 0] [1] >= [1 0] @n' + [0 0] @xs + [1] [0 0] [1 0] [1] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [1 0] @n' + [1] [0 0] [0] > [0] [0] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [1 0] @l1 + [0 0] @l2 + [1] [1 1] [1 0] [1] >= [1 0] @l1 + [0 0] @l2 + [1] [1 0] [1 0] [1] = [tuple#2(::(@x, @l1), @l2)] [zipWithAnd#1(::(@x, @xs), @l2)] = [1 0] @xs + [1] [0 0] [0] >= [1 0] @xs + [1] [0 0] [0] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [0] [0] >= [0] [0] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [1 0] @xs + [1] [0 0] [0] >= [1 0] @xs + [1] [0 0] [0] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [1 0] @xs + [1] [0 0] [0] > [0] [0] = [nil()] [zipWithOr#1(::(@x, @xs), @l2)] = [1 0] @xs + [1] [0 0] [0] >= [1 0] @xs + [1] [0 0] [0] = [zipWithOr#2(@l2, @x, @xs)] [zipWithOr#1(nil(), @l2)] = [0] [0] >= [0] [0] = [nil()] [zipWithOr#2(::(@y, @ys), @x, @xs)] = [1 0] @xs + [1] [0 0] [0] >= [1 0] @xs + [1] [0 0] [0] = [::(or(@x, @y), zipWithOr(@xs, @ys))] [zipWithOr#2(nil(), @x, @xs)] = [1 0] @xs + [1] [0 0] [0] > [0] [0] = [nil()] [#pred(#0())] = [2] [4] >= [2] [2] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [2] [2] > [0] [2] = [#0()] [#pred(#pos(#s(#s(@x))))] = [2] [2] > [0] [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [0 0] @x + [2] [1 0] [4] >= [0 0] @x + [2] [1 0] [3] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] [2] >= [0] [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] [0] >= [0] [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [2] [2] > [0] [2] = [#0()] [#succ(#neg(#s(#s(@x))))] = [0 0] @x + [2] [1 0] [3] >= [0 0] @x + [2] [1 0] [2] = [#neg(#s(@x))] [append^#(@l, @ys)] = [1 0] @l + [0] [0 0] [1] >= [1 0] @l + [0] [0 0] [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [1 0] @xs + [1] [0 0] [0] > [1 0] @xs + [0] [0 0] [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [0 0] @l + [0] [2 0] [0] >= [0] [0] = [c_6(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [0] [0] >= [0] [0] = [c_7(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [0] [1] >= [0] [0] = [c_8(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l))] [bitonicMerge#3^#(@h, @direction, @l)] = [2 0] @h + [0] [0 0] [1] >= [2 0] @h + [0] [0 0] [0] = [c_9(bitonicMerge#4^#(splitAt(@h, @l), @direction))] [length^#(@l)] = [0] [0] >= [0] [0] = [c_3(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] [0] >= [0] [0] = [c_10(length^#(@xs))] [bitonicMerge#4^#(@s, @direction)] = [2 0] @s + [0] [0 1] [0] >= [2 0] @s + [0] [0 0] [0] = [c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s))] [bitonicMerge#5^#(@hi, @direction, @s)] = [1 2] @hi + [1 0] @s + [0] [0 0] [0 0] [0] >= [1 1] @hi + [1 0] @s + [0] [0 0] [0 0] [0] = [c_12(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s))] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0] [0] >= [0] [0] = [c_13(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [0 0] @l1 + [0 0] @l2 + [0] [1 1] [1 0] [1] >= [0] [0] = [c_4(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [1 1] @hi + [1 1] @low + [0] [0 0] [0 0] [0] >= [1 1] @hi + [1 1] @low + [0] [0 0] [0 0] [0] = [c_14(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0] [0] >= [0] [0] = [c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [0] [0] >= [0] [0] = [c_5(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1 1] @hi + [1 0] @low + [0] [0 0] [0 0] [0] >= [1 0] @low + [0] [0 0] [0] = [c_16(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [zipWithOr#1^#(::(@x, @xs), @l2)] = [0] [0] >= [0] [0] = [c_17(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [0] [1] >= [0] [0] = [c_18(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [2 0] @l + [0] [0 0] [0] >= [2 0] @l + [0] [0 0] [0] = [c_19(bitonicSort#1^#(@l, @dir, @l))] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [2 0] @l + [0] [0 0] [0] >= [2 0] @l + [0] [0 0] [0] = [c_20(bitonicSort#2^#(split(@l), @dir))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [2 2] @l1 + [2 0] @l2 + [0] [0 0] [0 0] [0] >= [2 0] @l1 + [0] [0 0] [0] = [c_21(bitonicSort^#(@l1, #true()))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [2 2] @l1 + [2 0] @l2 + [0] [0 0] [0 0] [0] >= [1 0] @l1 + [2 0] @l2 + [0] [0 0] [0 0] [0] = [c_22(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [1 0] @l1 + [2 0] @l2 + [0] [0 0] [1 1] [0] >= [2 0] @l2 + [0] [0 0] [0] = [c_23(bitonicSort^#(@l2, #false()))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [1 0] @l1 + [2 0] @l2 + [0] [0 0] [1 1] [0] >= [1 0] @l1 + [0] [0 0] [0] = [c_24(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2))] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [1 0] @l1 + [0] [0 0] [0] >= [1 0] @l1 + [0] [0 0] [0] = [c_25(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2))] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [0 0] @xs + [0] [1 1] [1] >= [0] [0] = [c_26(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [0 0] @xs + [0] [1 0] [1] >= [0] [0] = [c_27(zipWithOr^#(@xs, @ys))] The strictly oriented rules are moved into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , length^#(@l) -> c_3(length#1^#(@l)) , zipWithOr^#(@l1, @l2) -> c_4(zipWithOr#1^#(@l1, @l2)) , zipWithAnd^#(@l1, @l2) -> c_5(zipWithAnd#1^#(@l1, @l2)) } Weak DPs: { append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> c_6(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_7(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_8(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_9(bitonicMerge#4^#(splitAt(@h, @l), @direction)) , length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_12(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_13(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_14(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_16(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_17(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_18(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> c_19(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_20(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_21(bitonicSort^#(@l1, #true())) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_22(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_23(bitonicSort^#(@l2, #false())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_24(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_25(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_26(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_27(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We decompose the input problem according to the dependency graph into the upper component { bitonicMerge^#(@l, @direction) -> c_6(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_7(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_8(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_9(bitonicMerge#4^#(splitAt(@h, @l), @direction)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_12(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_14(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_16(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , bitonicSort^#(@l, @dir) -> c_19(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_20(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_21(bitonicSort^#(@l1, #true())) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_22(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_23(bitonicSort^#(@l2, #false())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_24(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_25(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) } and lower component { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , length^#(@l) -> c_3(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_13(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_4(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_5(zipWithAnd#1^#(@l1, @l2)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_17(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_18(zipWithAnd#2^#(@l2, @x, @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_26(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_27(zipWithOr^#(@xs, @ys)) } Further, following extension rules are added to the lower component. { bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#6^#(@s) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#8^#(@s) , bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) } TcT solves the upper component with certificate YES(O(1),O(n^1)). Sub-proof: ---------- We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_8(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_12(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_16(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_25(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) } Weak DPs: { bitonicMerge^#(@l, @direction) -> c_6(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_7(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_9(bitonicMerge#4^#(splitAt(@h, @l), @direction)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_14(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicSort^#(@l, @dir) -> c_19(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_20(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_21(bitonicSort^#(@l1, #true())) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_22(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_23(bitonicSort^#(@l2, #false())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_24(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_8(bitonicMerge#3^#(div2(length(@l)), @direction, @l), length^#(@l)) , bitonicMerge#4^#(@s, @direction) -> c_11(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s), bitonicMerge#6^#(@s)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_12(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi), bitonicMerge#8^#(@s)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_16(append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)), bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_25(bitonicMerge^#(append(@l1, @l2), @dir), append^#(@l1, @l2)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_1(bitonicMerge#3^#(div2(length(@l)), @direction, @l)) , bitonicMerge#4^#(@s, @direction) -> c_2(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_3(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_4(bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_5(bitonicMerge^#(append(@l1, @l2), @dir)) } Weak DPs: { bitonicMerge^#(@l, @direction) -> c_6(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_7(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_8(bitonicMerge#4^#(splitAt(@h, @l), @direction)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_9(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicSort^#(@l, @dir) -> c_10(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_11(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_12(bitonicSort^#(@l1, #true())) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_13(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_14(bitonicSort^#(@l2, #false())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_15(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We estimate the number of application of {3} by applications of Pre({3}) = {2}. Here rules are labeled as follows: DPs: { 1: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_1(bitonicMerge#3^#(div2(length(@l)), @direction, @l)) , 2: bitonicMerge#4^#(@s, @direction) -> c_2(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s)) , 3: bitonicMerge#5^#(@hi, @direction, @s) -> c_3(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi)) , 4: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_4(bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , 5: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_5(bitonicMerge^#(append(@l1, @l2), @dir)) , 6: bitonicMerge^#(@l, @direction) -> c_6(bitonicMerge#1^#(@l, @direction, @l)) , 7: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_7(bitonicMerge#2^#(@xs, @direction, @l)) , 8: bitonicMerge#3^#(@h, @direction, @l) -> c_8(bitonicMerge#4^#(splitAt(@h, @l), @direction)) , 9: bitonicMerge#7^#(@low, @direction, @hi) -> c_9(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , 10: bitonicSort^#(@l, @dir) -> c_10(bitonicSort#1^#(@l, @dir, @l)) , 11: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_11(bitonicSort#2^#(split(@l), @dir)) , 12: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_12(bitonicSort^#(@l1, #true())) , 13: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_13(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , 14: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_14(bitonicSort^#(@l2, #false())) , 15: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_15(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_1(bitonicMerge#3^#(div2(length(@l)), @direction, @l)) , bitonicMerge#4^#(@s, @direction) -> c_2(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_4(bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_5(bitonicMerge^#(append(@l1, @l2), @dir)) } Weak DPs: { bitonicMerge^#(@l, @direction) -> c_6(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_7(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_8(bitonicMerge#4^#(splitAt(@h, @l), @direction)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_3(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_9(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicSort^#(@l, @dir) -> c_10(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_11(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_12(bitonicSort^#(@l1, #true())) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_13(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_14(bitonicSort^#(@l2, #false())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_15(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 3: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_4(bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , 4: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_5(bitonicMerge^#(append(@l1, @l2), @dir)) , 7: bitonicMerge#3^#(@h, @direction, @l) -> c_8(bitonicMerge#4^#(splitAt(@h, @l), @direction)) , 15: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_15(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) } Trs: { #add(#0(), @y) -> @y , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#0()) -> #pos(#s(#0())) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1, 2}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1}, Uargs(c_9) = {1}, Uargs(c_10) = {1}, Uargs(c_11) = {1}, Uargs(c_12) = {1}, Uargs(c_13) = {1}, Uargs(c_14) = {1}, Uargs(c_15) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [+](x1, x2) = [2 0] x1 + [1 0] x2 + [0] [1 2] [0 1] [0] [#add](x1, x2) = [2 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [and](x1, x2) = [1] [0] [#and](x1, x2) = [0] [0] [append](x1, x2) = [1 2] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [append#1](x1, x2) = [1 2] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [::](x1, x2) = [1 0] x1 + [1 0] x2 + [1] [0 0] [0 1] [1] [append#2](x1, x2) = [1 0] x1 + [1 0] x2 + [1] [0 1] [0 0] [1] [nil] = [2] [0] [bitonicMerge](x1, x2) = [0] [0] [bitonicMerge#1](x1, x2, x3) = [2 0] x2 + [0] [2 2] [0] [bitonicMerge#2](x1, x2, x3) = [2 0] x2 + [2 0] x3 + [0] [2 2] [0 1] [0] [#false] = [0] [0] [bitonicMerge#10](x1, x2, x3) = [0 1] x2 + [0 1] x3 + [1] [0 2] [0 1] [2] [tuple#2](x1, x2) = [0 1] x1 + [0 1] x2 + [1] [0 1] [0 0] [0] [#true] = [0] [0] [length](x1) = [2 2] x1 + [0] [0 0] [0] [div2](x1) = [0 0] x1 + [2] [0 1] [0] [bitonicMerge#3](x1, x2, x3) = [0] [0] [splitAt](x1, x2) = [0 0] x1 + [2 1] x2 + [2] [0 1] [0 0] [0] [bitonicMerge#4](x1, x2) = [2 0] x2 + [0] [2 0] [0] [bitonicMerge#6](x1) = [2 0] x1 + [0] [0 1] [0] [bitonicMerge#5](x1, x2, x3) = [2 0] x2 + [0] [0 2] [0] [bitonicMerge#8](x1) = [2 0] x1 + [0] [0 1] [0] [bitonicMerge#7](x1, x2, x3) = [2 0] x2 + [2 0] x3 + [0] [0 2] [2 2] [0] [zipWithOr](x1, x2) = [0 1] x1 + [0 2] x2 + [2] [0 1] [0 0] [0] [bitonicMerge#9](x1, x2) = [0] [0] [zipWithAnd](x1, x2) = [0 0] x1 + [0 2] x2 + [2] [0 1] [0 0] [0] [bitonicSort](x1, x2) = [0] [0] [bitonicSort#1](x1, x2, x3) = [2 0] x2 + [0] [2 2] [0] [split](x1) = [0 1] x1 + [1] [2 0] [1] [bitonicSort#2](x1, x2) = [2 0] x2 + [0] [2 2] [0] [bitonicSort#3](x1, x2, x3, x4) = [2 0] x2 + [2 0] x4 + [0] [2 2] [0 2] [0] [bitonicSort#4](x1, x2, x3, x4) = [0] [0] [div2#1](x1) = [0 0] x1 + [2] [0 1] [0] [#0] = [2] [0] [#s](x1) = [0 0] x1 + [0] [0 1] [1] [div2#2](x1) = [0 0] x1 + [2] [0 1] [1] [#pos](x1) = [0 0] x1 + [0] [1 0] [0] [length#1](x1) = [2 2] x1 + [0] [0 0] [0] [or](x1, x2) = [0] [0] [#or](x1, x2) = [0] [0] [split#1](x1) = [0 1] x1 + [1] [2 0] [1] [split#2](x1, x2) = [0 1] x1 + [0 0] x2 + [2] [2 0] [2 0] [1] [split#3](x1, x2, x3) = [1 0] x1 + [0 0] x3 + [2] [0 1] [2 0] [1] [splitAt#1](x1, x2) = [0 0] x1 + [2 1] x2 + [2] [0 1] [0 0] [0] [splitAt#2](x1, x2) = [2 1] x1 + [0 0] x2 + [1] [0 0] [0 1] [1] [splitAt#3](x1, x2) = [1 0] x1 + [1] [0 1] [1] [zipWithAnd#1](x1, x2) = [0 0] x1 + [0 2] x2 + [2] [0 1] [0 0] [0] [zipWithAnd#2](x1, x2, x3) = [0 2] x1 + [0 0] x3 + [2] [0 0] [0 1] [1] [zipWithOr#1](x1, x2) = [0 1] x1 + [0 2] x2 + [2] [0 1] [0 0] [0] [zipWithOr#2](x1, x2, x3) = [0 2] x1 + [0 1] x3 + [2] [0 0] [0 1] [1] [#neg](x1) = [1 0] x1 + [2] [1 0] [0] [#pred](x1) = [2] [0] [#succ](x1) = [1 0] x1 + [0] [0 1] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [and^#](x1, x2) = [0] [0] [#and^#](x1, x2) = [0] [0] [append^#](x1, x2) = [0] [0] [append#1^#](x1, x2) = [0] [0] [append#2^#](x1, x2) = [0] [0] [bitonicMerge^#](x1, x2) = [0 1] x1 + [0 0] x2 + [0] [1 2] [0 1] [1] [bitonicMerge#1^#](x1, x2, x3) = [0 1] x1 + [0] [0 0] [0] [bitonicMerge#2^#](x1, x2, x3) = [0 1] x1 + [1] [0 0] [1] [bitonicMerge#3^#](x1, x2, x3) = [0 2] x1 + [2] [0 0] [0] [div2^#](x1) = [0] [0] [length^#](x1) = [0] [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [0] [length#1^#](x1) = [0] [0] [div2#1^#](x1) = [0] [0] [bitonicMerge#4^#](x1, x2) = [0 2] x1 + [1] [0 0] [0] [splitAt^#](x1, x2) = [0] [0] [splitAt#1^#](x1, x2) = [0] [0] [bitonicMerge#5^#](x1, x2, x3) = [0 1] x1 + [0 1] x3 + [1] [0 0] [0 0] [1] [bitonicMerge#6^#](x1) = [0] [0] [zipWithOr^#](x1, x2) = [0] [0] [bitonicMerge#7^#](x1, x2, x3) = [0 1] x1 + [0 1] x3 + [1] [0 0] [0 0] [0] [bitonicMerge#8^#](x1) = [0] [0] [zipWithAnd^#](x1, x2) = [0] [0] [bitonicMerge#9^#](x1, x2) = [1 0] x1 + [0] [0 0] [0] [zipWithOr#1^#](x1, x2) = [0] [0] [zipWithAnd#1^#](x1, x2) = [0] [0] [bitonicSort^#](x1, x2) = [0 2] x1 + [2] [0 0] [0] [bitonicSort#1^#](x1, x2, x3) = [0 2] x3 + [2] [0 0] [0] [bitonicSort#2^#](x1, x2) = [2 0] x1 + [0] [0 0] [0] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [bitonicSort#3^#](x1, x2, x3, x4) = [0 2] x3 + [0 2] x4 + [2] [0 0] [1 1] [0] [bitonicSort#4^#](x1, x2, x3, x4) = [0 2] x3 + [0 2] x4 + [1] [0 0] [0 0] [0] [div2#2^#](x1) = [0] [0] [or^#](x1, x2) = [0] [0] [#or^#](x1, x2) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [splitAt#2^#](x1, x2) = [0] [0] [splitAt#3^#](x1, x2) = [0] [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [0] [zipWithOr#2^#](x1, x2, x3) = [0] [0] [#succ^#](x1) = [0] [0] [#pred^#](x1) = [0] [0] [c_6](x1) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1, x2) = [0] [0] [c_9](x1) = [0] [0] [c_11](x1, x2) = [0] [0] [c_12](x1, x2) = [0] [0] [c_14](x1) = [0] [0] [c_16](x1, x2, x3) = [0] [0] [c_19](x1) = [0] [0] [c_20](x1) = [0] [0] [c_21](x1) = [0] [0] [c_22](x1) = [0] [0] [c_23](x1) = [0] [0] [c_24](x1) = [0] [0] [c_25](x1, x2) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [0] [c_2](x1) = [1 0] x1 + [0] [0 0] [0] [c_3](x1) = [1 0] x1 + [0] [0 0] [0] [c_4](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_5](x1) = [2 0] x1 + [0] [0 0] [0] [c_6](x1) = [1 0] x1 + [0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_8](x1) = [1 0] x1 + [0] [0 0] [0] [c_9](x1) = [1 0] x1 + [0] [0 0] [0] [c_10](x1) = [1 0] x1 + [0] [0 0] [0] [c_11](x1) = [1 0] x1 + [0] [0 0] [0] [c_12](x1) = [1 0] x1 + [0] [0 0] [0] [c_13](x1) = [1 0] x1 + [0] [0 0] [0] [c_14](x1) = [1 0] x1 + [0] [0 0] [0] [c_15](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [+(@x, @y)] = [2 0] @x + [1 0] @y + [0] [1 2] [0 1] [0] >= [2 0] @x + [1 0] @y + [0] [0 1] [0 1] [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1 0] @y + [4] [0 1] [0] > [1 0] @y + [0] [0 1] [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1 0] @y + [0] [0 1] [0] >= [1 0] @y + [0] [0 1] [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1 0] @y + [0] [0 1] [0] >= [1 0] @y + [0] [0 1] [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1 0] @y + [4] [0 1] [0] > [2] [0] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1 0] @y + [4] [0 1] [0] > [2] [0] = [#pred(#add(#pos(#s(@x)), @y))] [and(@x, @y)] = [1] [0] > [0] [0] = [#and(@x, @y)] [#and(#false(), #false())] = [0] [0] >= [0] [0] = [#false()] [#and(#false(), #true())] = [0] [0] >= [0] [0] = [#false()] [#and(#true(), #false())] = [0] [0] >= [0] [0] = [#false()] [#and(#true(), #true())] = [0] [0] >= [0] [0] = [#true()] [append(@l, @ys)] = [1 2] @l + [1 0] @ys + [0] [0 1] [0 1] [0] >= [1 2] @l + [1 0] @ys + [0] [0 1] [0 1] [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [1 0] @x + [1 2] @xs + [1 0] @ys + [3] [0 0] [0 1] [0 1] [1] > [1 0] @x + [1 2] @xs + [1 0] @ys + [1] [0 0] [0 1] [0 1] [1] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [1 0] @ys + [2] [0 1] [0] > [1 0] @ys + [0] [0 1] [0] = [@ys] [append#2(@l', @x)] = [1 0] @l' + [1 0] @x + [1] [0 1] [0 0] [1] >= [1 0] @l' + [1 0] @x + [1] [0 1] [0 0] [1] = [::(@x, @l')] [bitonicMerge#10(#false(), @hi, @low)] = [0 1] @hi + [0 1] @low + [1] [0 2] [0 1] [2] >= [0 1] @hi + [0 1] @low + [1] [0 0] [0 1] [0] = [tuple#2(@low, @hi)] [bitonicMerge#10(#true(), @hi, @low)] = [0 1] @hi + [0 1] @low + [1] [0 2] [0 1] [2] >= [0 1] @hi + [0 1] @low + [1] [0 1] [0 0] [0] = [tuple#2(@hi, @low)] [length(@l)] = [2 2] @l + [0] [0 0] [0] >= [2 2] @l + [0] [0 0] [0] = [length#1(@l)] [div2(@n)] = [0 0] @n + [2] [0 1] [0] >= [0 0] @n + [2] [0 1] [0] = [div2#1(@n)] [splitAt(@n, @l)] = [2 1] @l + [0 0] @n + [2] [0 0] [0 1] [0] >= [2 1] @l + [0 0] @n + [2] [0 0] [0 1] [0] = [splitAt#1(@n, @l)] [bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0 2] @zipWithOr@1 + [0 2] @zipWithOr@2 + [2] [0 1] [0 0] [0] >= [0 1] @zipWithOr@1 + [0 2] @zipWithOr@2 + [2] [0 1] [0 0] [0] = [zipWithOr(@zipWithOr@1, @zipWithOr@2)] [bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0 2] @zipWithAnd@3 + [0 2] @zipWithAnd@4 + [2] [0 1] [0 0] [0] >= [0 0] @zipWithAnd@3 + [0 2] @zipWithAnd@4 + [2] [0 1] [0 0] [0] = [zipWithAnd(@zipWithAnd@3, @zipWithAnd@4)] [zipWithOr(@l1, @l2)] = [0 1] @l1 + [0 2] @l2 + [2] [0 1] [0 0] [0] >= [0 1] @l1 + [0 2] @l2 + [2] [0 1] [0 0] [0] = [zipWithOr#1(@l1, @l2)] [zipWithAnd(@l1, @l2)] = [0 0] @l1 + [0 2] @l2 + [2] [0 1] [0 0] [0] >= [0 0] @l1 + [0 2] @l2 + [2] [0 1] [0 0] [0] = [zipWithAnd#1(@l1, @l2)] [split(@l)] = [0 1] @l + [1] [2 0] [1] >= [0 1] @l + [1] [2 0] [1] = [split#1(@l)] [div2#1(#0())] = [2] [0] >= [2] [0] = [#0()] [div2#1(#s(@n))] = [0 0] @n + [2] [0 1] [1] >= [0 0] @n + [2] [0 1] [1] = [div2#2(@n)] [div2#2(#0())] = [2] [1] >= [2] [0] = [#0()] [div2#2(#s(@n))] = [0 0] @n + [2] [0 1] [2] >= [0 0] @n + [2] [0 1] [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [2 0] @x + [2 2] @xs + [4] [0 0] [0 0] [0] > [2 2] @xs + [0] [0 0] [0] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [4] [0] > [2] [0] = [#0()] [or(@x, @y)] = [0] [0] >= [0] [0] = [#or(@x, @y)] [#or(#false(), #false())] = [0] [0] >= [0] [0] = [#false()] [#or(#false(), #true())] = [0] [0] >= [0] [0] = [#true()] [#or(#true(), #false())] = [0] [0] >= [0] [0] = [#true()] [#or(#true(), #true())] = [0] [0] >= [0] [0] = [#true()] [split#1(::(@x1, @xs))] = [0 0] @x1 + [0 1] @xs + [2] [2 0] [2 0] [3] >= [0 0] @x1 + [0 1] @xs + [2] [2 0] [2 0] [1] = [split#2(@xs, @x1)] [split#1(nil())] = [1] [5] >= [1] [0] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [0 0] @x1 + [0 0] @x2 + [0 1] @xs' + [3] [2 0] [2 0] [2 0] [3] >= [0 0] @x2 + [0 1] @xs' + [3] [2 0] [2 0] [2] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [0 0] @x1 + [2] [2 0] [5] > [1] [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [0 1] @l1 + [0 1] @l2 + [0 0] @x2 + [3] [0 1] [0 0] [2 0] [1] >= [0 1] @l1 + [0 1] @l2 + [3] [0 1] [0 0] [1] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [splitAt#1(#0(), @l)] = [2 1] @l + [2] [0 0] [0] > [0 1] @l + [1] [0 0] [0] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [2 1] @l + [0 0] @n' + [2] [0 0] [0 1] [1] > [2 1] @l + [0 0] @n' + [1] [0 0] [0 1] [1] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [0 0] @n' + [2 0] @x + [2 1] @xs + [4] [0 1] [0 0] [0 0] [1] > [0 0] @n' + [2 1] @xs + [3] [0 1] [0 0] [1] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [0 0] @n' + [5] [0 1] [1] > [1] [0] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [0 1] @l1 + [0 1] @l2 + [2] [0 1] [0 0] [1] >= [0 1] @l1 + [0 1] @l2 + [2] [0 1] [0 0] [1] = [tuple#2(::(@x, @l1), @l2)] [zipWithAnd#1(::(@x, @xs), @l2)] = [0 2] @l2 + [0 0] @xs + [2] [0 0] [0 1] [1] >= [0 2] @l2 + [0 0] @xs + [2] [0 0] [0 1] [1] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [0 2] @l2 + [2] [0 0] [0] >= [2] [0] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [0 0] @xs + [0 2] @ys + [4] [0 1] [0 0] [1] >= [0 0] @xs + [0 2] @ys + [4] [0 1] [0 0] [1] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [0 0] @xs + [2] [0 1] [1] >= [2] [0] = [nil()] [zipWithOr#1(::(@x, @xs), @l2)] = [0 2] @l2 + [0 1] @xs + [3] [0 0] [0 1] [1] > [0 2] @l2 + [0 1] @xs + [2] [0 0] [0 1] [1] = [zipWithOr#2(@l2, @x, @xs)] [zipWithOr#1(nil(), @l2)] = [0 2] @l2 + [2] [0 0] [0] >= [2] [0] = [nil()] [zipWithOr#2(::(@y, @ys), @x, @xs)] = [0 1] @xs + [0 2] @ys + [4] [0 1] [0 0] [1] > [0 1] @xs + [0 2] @ys + [3] [0 1] [0 0] [1] = [::(or(@x, @y), zipWithOr(@xs, @ys))] [zipWithOr#2(nil(), @x, @xs)] = [0 1] @xs + [2] [0 1] [1] >= [2] [0] = [nil()] [#pred(#0())] = [2] [0] >= [2] [0] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [2] [0] >= [2] [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [2] [0] > [0] [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [2] [0] >= [2] [0] = [#neg(#s(#s(@x)))] [#succ(#0())] = [2] [0] > [0] [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] [0] >= [0] [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [2] [0] >= [2] [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [2] [0] >= [2] [0] = [#neg(#s(@x))] [bitonicMerge^#(@l, @direction)] = [0 0] @direction + [0 1] @l + [0] [0 1] [1 2] [1] >= [0 1] @l + [0] [0 0] [0] = [c_6(bitonicMerge#1^#(@l, @direction, @l))] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [0 1] @xs + [1] [0 0] [0] >= [0 1] @xs + [1] [0 0] [0] = [c_7(bitonicMerge#2^#(@xs, @direction, @l))] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [0 1] @ys + [2] [0 0] [1] >= [2] [0] = [c_1(bitonicMerge#3^#(div2(length(@l)), @direction, @l))] [bitonicMerge#3^#(@h, @direction, @l)] = [0 2] @h + [2] [0 0] [0] > [0 2] @h + [1] [0 0] [0] = [c_8(bitonicMerge#4^#(splitAt(@h, @l), @direction))] [bitonicMerge#4^#(@s, @direction)] = [0 2] @s + [1] [0 0] [0] >= [0 2] @s + [1] [0 0] [0] = [c_2(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s))] [bitonicMerge#5^#(@hi, @direction, @s)] = [0 1] @hi + [0 1] @s + [1] [0 0] [0 0] [1] >= [0 1] @hi + [0 1] @s + [1] [0 0] [0 0] [0] = [c_3(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi))] [bitonicMerge#7^#(@low, @direction, @hi)] = [0 1] @hi + [0 1] @low + [1] [0 0] [0 0] [0] >= [0 1] @hi + [0 1] @low + [1] [0 0] [0 0] [0] = [c_9(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [0 1] @hi + [0 1] @low + [1] [0 0] [0 0] [0] > [0 1] @hi + [0 1] @low + [0] [0 0] [0 0] [0] = [c_4(bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction))] [bitonicSort^#(@l, @dir)] = [0 2] @l + [2] [0 0] [0] >= [0 2] @l + [2] [0 0] [0] = [c_10(bitonicSort#1^#(@l, @dir, @l))] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [0 2] @l + [2] [0 0] [0] >= [0 2] @l + [2] [0 0] [0] = [c_11(bitonicSort#2^#(split(@l), @dir))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [0 2] @l1 + [0 2] @l2 + [2] [0 0] [0 0] [0] >= [0 2] @l1 + [2] [0 0] [0] = [c_12(bitonicSort^#(@l1, #true()))] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [0 2] @l1 + [0 2] @l2 + [2] [0 0] [0 0] [0] >= [0 2] @l1 + [0 2] @l2 + [2] [0 0] [0 0] [0] = [c_13(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [0 2] @l1 + [0 2] @l2 + [2] [0 0] [1 1] [0] >= [0 2] @l2 + [2] [0 0] [0] = [c_14(bitonicSort^#(@l2, #false()))] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [0 2] @l1 + [0 2] @l2 + [2] [0 0] [1 1] [0] > [0 2] @l1 + [0 2] @l2 + [1] [0 0] [0 0] [0] = [c_15(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2))] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [0 2] @l1 + [0 2] @l2 + [1] [0 0] [0 0] [0] > [0 2] @l1 + [0 2] @l2 + [0] [0 0] [0 0] [0] = [c_5(bitonicMerge^#(append(@l1, @l2), @dir))] Consider the set of all dependency pairs DPs: { 1: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_1(bitonicMerge#3^#(div2(length(@l)), @direction, @l)) , 2: bitonicMerge#4^#(@s, @direction) -> c_2(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s)) , 3: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_4(bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , 4: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_5(bitonicMerge^#(append(@l1, @l2), @dir)) , 5: bitonicMerge^#(@l, @direction) -> c_6(bitonicMerge#1^#(@l, @direction, @l)) , 6: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_7(bitonicMerge#2^#(@xs, @direction, @l)) , 7: bitonicMerge#3^#(@h, @direction, @l) -> c_8(bitonicMerge#4^#(splitAt(@h, @l), @direction)) , 8: bitonicMerge#5^#(@hi, @direction, @s) -> c_3(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi)) , 9: bitonicMerge#7^#(@low, @direction, @hi) -> c_9(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , 10: bitonicSort^#(@l, @dir) -> c_10(bitonicSort#1^#(@l, @dir, @l)) , 11: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_11(bitonicSort#2^#(split(@l), @dir)) , 12: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_12(bitonicSort^#(@l1, #true())) , 13: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_13(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , 14: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_14(bitonicSort^#(@l2, #false())) , 15: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_15(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {3,4,7,15}. These cover all (indirect) predecessors of dependency pairs {1,2,3,4,5,6,7,8,9,15}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { bitonicMerge^#(@l, @direction) -> c_6(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_7(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_1(bitonicMerge#3^#(div2(length(@l)), @direction, @l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_8(bitonicMerge#4^#(splitAt(@h, @l), @direction)) , bitonicMerge#4^#(@s, @direction) -> c_2(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_3(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_9(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_4(bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , bitonicSort^#(@l, @dir) -> c_10(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_11(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_12(bitonicSort^#(@l1, #true())) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_13(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_14(bitonicSort^#(@l2, #false())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_15(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_5(bitonicMerge^#(append(@l1, @l2), @dir)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { bitonicMerge^#(@l, @direction) -> c_6(bitonicMerge#1^#(@l, @direction, @l)) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> c_7(bitonicMerge#2^#(@xs, @direction, @l)) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> c_1(bitonicMerge#3^#(div2(length(@l)), @direction, @l)) , bitonicMerge#3^#(@h, @direction, @l) -> c_8(bitonicMerge#4^#(splitAt(@h, @l), @direction)) , bitonicMerge#4^#(@s, @direction) -> c_2(bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s)) , bitonicMerge#5^#(@hi, @direction, @s) -> c_3(bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi)) , bitonicMerge#7^#(@low, @direction, @hi) -> c_9(bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> c_4(bitonicMerge^#(@low, @direction), bitonicMerge^#(@hi, @direction)) , bitonicSort^#(@l, @dir) -> c_10(bitonicSort#1^#(@l, @dir, @l)) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> c_11(bitonicSort#2^#(split(@l), @dir)) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_12(bitonicSort^#(@l1, #true())) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> c_13(bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_14(bitonicSort^#(@l2, #false())) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> c_15(bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> c_5(bitonicMerge^#(append(@l1, @l2), @dir)) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded We return to the main proof. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , length^#(@l) -> c_3(length#1^#(@l)) , zipWithOr^#(@l1, @l2) -> c_4(zipWithOr#1^#(@l1, @l2)) , zipWithAnd^#(@l1, @l2) -> c_5(zipWithAnd#1^#(@l1, @l2)) } Weak DPs: { append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#6^#(@s) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#8^#(@s) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_13(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_17(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_18(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_26(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_27(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 3: zipWithOr^#(@l1, @l2) -> c_4(zipWithOr#1^#(@l1, @l2)) , 9: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , 18: bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , 19: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , 30: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) } Trs: { #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_10) = {1}, Uargs(c_13) = {1}, Uargs(c_15) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1}, Uargs(c_26) = {1}, Uargs(c_27) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [1] x1 + [1] x2 + [0] [#add](x1, x2) = [1] x1 + [1] x2 + [0] [and](x1, x2) = [0] [#and](x1, x2) = [1] x1 + [1] x2 + [0] [append](x1, x2) = [0] [append#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x2 + [1] [append#2](x1, x2) = [0] [nil] = [0] [bitonicMerge](x1, x2) = [0] [bitonicMerge#1](x1, x2, x3) = [1] x3 + [1] [bitonicMerge#2](x1, x2, x3) = [1] x1 + [1] x3 + [0] [#false] = [0] [bitonicMerge#10](x1, x2, x3) = [0] [tuple#2](x1, x2) = [1] x1 + [0] [#true] = [0] [length](x1) = [0] [div2](x1) = [1] x1 + [0] [bitonicMerge#3](x1, x2, x3) = [0] [splitAt](x1, x2) = [1] x1 + [0] [bitonicMerge#4](x1, x2) = [0] [bitonicMerge#6](x1) = [0] [bitonicMerge#5](x1, x2, x3) = [1] x1 + [0] [bitonicMerge#8](x1) = [0] [bitonicMerge#7](x1, x2, x3) = [1] x1 + [0] [zipWithOr](x1, x2) = [0] [bitonicMerge#9](x1, x2) = [1] x1 + [0] [zipWithAnd](x1, x2) = [0] [bitonicSort](x1, x2) = [0] [bitonicSort#1](x1, x2, x3) = [1] [split](x1) = [0] [bitonicSort#2](x1, x2) = [0] [bitonicSort#3](x1, x2, x3, x4) = [0] [bitonicSort#4](x1, x2, x3, x4) = [0] [div2#1](x1) = [1] x1 + [0] [#0] = [0] [#s](x1) = [1] x1 + [1] [div2#2](x1) = [1] x1 + [1] [#pos](x1) = [0] [length#1](x1) = [0] [or](x1, x2) = [0] [#or](x1, x2) = [1] x1 + [1] x2 + [0] [split#1](x1) = [0] [split#2](x1, x2) = [0] [split#3](x1, x2, x3) = [0] [splitAt#1](x1, x2) = [1] x1 + [0] [splitAt#2](x1, x2) = [1] x2 + [1] [splitAt#3](x1, x2) = [1] x1 + [1] [zipWithAnd#1](x1, x2) = [1] [zipWithAnd#2](x1, x2, x3) = [1] [zipWithOr#1](x1, x2) = [1] [zipWithOr#2](x1, x2, x3) = [0] [#neg](x1) = [1] x1 + [0] [#pred](x1) = [1] x1 + [1] [#succ](x1) = [1] x1 + [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [and^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [append^#](x1, x2) = [0] [append#1^#](x1, x2) = [0] [append#2^#](x1, x2) = [0] [bitonicMerge^#](x1, x2) = [1] [bitonicMerge#1^#](x1, x2, x3) = [1] [bitonicMerge#2^#](x1, x2, x3) = [1] [bitonicMerge#3^#](x1, x2, x3) = [1] x1 + [1] [div2^#](x1) = [0] [length^#](x1) = [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [length#1^#](x1) = [0] [div2#1^#](x1) = [0] [bitonicMerge#4^#](x1, x2) = [1] x1 + [1] [splitAt^#](x1, x2) = [0] [splitAt#1^#](x1, x2) = [0] [bitonicMerge#5^#](x1, x2, x3) = [1] [bitonicMerge#6^#](x1) = [1] x1 + [1] [zipWithOr^#](x1, x2) = [1] x1 + [1] [bitonicMerge#7^#](x1, x2, x3) = [1] [bitonicMerge#8^#](x1) = [1] [zipWithAnd^#](x1, x2) = [0] [bitonicMerge#9^#](x1, x2) = [1] [zipWithOr#1^#](x1, x2) = [1] x1 + [0] [zipWithAnd#1^#](x1, x2) = [0] [bitonicSort^#](x1, x2) = [1] [bitonicSort#1^#](x1, x2, x3) = [1] [bitonicSort#2^#](x1, x2) = [1] [split^#](x1) = [0] [split#1^#](x1) = [0] [bitonicSort#3^#](x1, x2, x3, x4) = [1] [bitonicSort#4^#](x1, x2, x3, x4) = [1] [div2#2^#](x1) = [0] [or^#](x1, x2) = [0] [#or^#](x1, x2) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [splitAt#2^#](x1, x2) = [0] [splitAt#3^#](x1, x2) = [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [zipWithOr#2^#](x1, x2, x3) = [1] x3 + [1] [#succ^#](x1) = [0] [#pred^#](x1) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_13](x1) = [1] x1 + [0] [c_15](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] [c_26](x1) = [1] x1 + [0] [c_27](x1) = [1] x1 + [0] This order satisfies following ordering constraints [+(@x, @y)] = [1] @x + [1] @y + [0] >= [1] @x + [1] @y + [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1] @y + [1] >= [1] @y + [1] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1] @x + [1] @y + [2] > [1] @y + [1] = [#pred(#add(#pos(#s(@x)), @y))] [length(@l)] = [0] >= [0] = [length#1(@l)] [div2(@n)] = [1] @n + [0] >= [1] @n + [0] = [div2#1(@n)] [splitAt(@n, @l)] = [1] @n + [0] >= [1] @n + [0] = [splitAt#1(@n, @l)] [div2#1(#0())] = [0] >= [0] = [#0()] [div2#1(#s(@n))] = [1] @n + [1] >= [1] @n + [1] = [div2#2(@n)] [div2#2(#0())] = [1] > [0] = [#0()] [div2#2(#s(@n))] = [1] @n + [2] > [1] @n + [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [0] >= [0] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [0] >= [0] = [#0()] [splitAt#1(#0(), @l)] = [0] >= [0] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [1] @n' + [1] >= [1] @n' + [1] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [1] @n' + [1] >= [1] @n' + [1] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [1] @n' + [1] > [0] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [1] @l1 + [1] >= [1] @l1 + [1] = [tuple#2(::(@x, @l1), @l2)] [#pred(#0())] = [1] >= [1] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [1] > [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [1] > [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [1] @x + [2] >= [1] @x + [2] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] >= [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] >= [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [1] > [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [1] @x + [2] > [1] @x + [1] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] >= [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] >= [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [1] >= [1] = [bitonicMerge#1^#(@l, @direction, @l)] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [1] >= [1] = [bitonicMerge#2^#(@xs, @direction, @l)] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [1] >= [1] = [bitonicMerge#3^#(div2(length(@l)), @direction, @l)] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [1] > [0] = [length^#(@l)] [bitonicMerge#3^#(@h, @direction, @l)] = [1] @h + [1] >= [1] @h + [1] = [bitonicMerge#4^#(splitAt(@h, @l), @direction)] [length^#(@l)] = [0] >= [0] = [c_3(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] >= [0] = [c_10(length^#(@xs))] [bitonicMerge#4^#(@s, @direction)] = [1] @s + [1] >= [1] = [bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s)] [bitonicMerge#4^#(@s, @direction)] = [1] @s + [1] >= [1] @s + [1] = [bitonicMerge#6^#(@s)] [bitonicMerge#5^#(@hi, @direction, @s)] = [1] >= [1] = [bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi)] [bitonicMerge#5^#(@hi, @direction, @s)] = [1] >= [1] = [bitonicMerge#8^#(@s)] [bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [1] @zipWithOr@1 + [1] >= [1] @zipWithOr@1 + [1] = [c_13(zipWithOr^#(@zipWithOr@1, @zipWithOr@2))] [zipWithOr^#(@l1, @l2)] = [1] @l1 + [1] > [1] @l1 + [0] = [c_4(zipWithOr#1^#(@l1, @l2))] [bitonicMerge#7^#(@low, @direction, @hi)] = [1] >= [1] = [bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [1] > [0] = [c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [0] >= [0] = [c_5(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1] > [0] = [append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1] >= [1] = [bitonicMerge^#(@hi, @direction)] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1] >= [1] = [bitonicMerge^#(@low, @direction)] [zipWithOr#1^#(::(@x, @xs), @l2)] = [1] @xs + [1] >= [1] @xs + [1] = [c_17(zipWithOr#2^#(@l2, @x, @xs))] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [0] >= [0] = [c_18(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [1] >= [1] = [bitonicSort#1^#(@l, @dir, @l)] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [1] >= [1] = [bitonicSort#2^#(split(@l), @dir)] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [1] >= [1] = [bitonicSort^#(@l1, #true())] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [1] >= [1] = [bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [1] >= [1] = [bitonicSort^#(@l2, #false())] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [1] >= [1] = [bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [1] > [0] = [append^#(@l1, @l2)] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [1] >= [1] = [bitonicMerge^#(append(@l1, @l2), @dir)] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [0] >= [0] = [c_26(zipWithAnd^#(@xs, @ys))] [zipWithOr#2^#(::(@y, @ys), @x, @xs)] = [1] @xs + [1] >= [1] @xs + [1] = [c_27(zipWithOr^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , 2: length^#(@l) -> c_3(length#1^#(@l)) , 3: zipWithOr^#(@l1, @l2) -> c_4(zipWithOr#1^#(@l1, @l2)) , 4: zipWithAnd^#(@l1, @l2) -> c_5(zipWithAnd#1^#(@l1, @l2)) , 5: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , 6: bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , 7: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , 8: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , 9: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , 10: bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , 11: length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) , 12: bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , 13: bitonicMerge#4^#(@s, @direction) -> bitonicMerge#6^#(@s) , 14: bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , 15: bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#8^#(@s) , 16: bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_13(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , 17: bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , 18: bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , 19: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , 20: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , 21: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , 22: zipWithOr#1^#(::(@x, @xs), @l2) -> c_17(zipWithOr#2^#(@l2, @x, @xs)) , 23: zipWithAnd#1^#(::(@x, @xs), @l2) -> c_18(zipWithAnd#2^#(@l2, @x, @xs)) , 24: bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , 25: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , 26: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , 27: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , 28: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , 29: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , 30: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , 31: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) , 32: zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_26(zipWithAnd^#(@xs, @ys)) , 33: zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_27(zipWithOr^#(@xs, @ys)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {3,9,18,19,30}. These cover all (indirect) predecessors of dependency pairs {3,9,18,19,22,30,33}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , length^#(@l) -> c_3(length#1^#(@l)) , zipWithAnd^#(@l1, @l2) -> c_5(zipWithAnd#1^#(@l1, @l2)) } Weak DPs: { append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#6^#(@s) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#8^#(@s) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_13(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_4(zipWithOr#1^#(@l1, @l2)) , bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_17(zipWithOr#2^#(@l2, @x, @xs)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_18(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_26(zipWithAnd^#(@xs, @ys)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_27(zipWithOr^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { bitonicMerge#4^#(@s, @direction) -> bitonicMerge#6^#(@s) , bitonicMerge#6^#(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> c_13(zipWithOr^#(@zipWithOr@1, @zipWithOr@2)) , zipWithOr^#(@l1, @l2) -> c_4(zipWithOr#1^#(@l1, @l2)) , zipWithOr#1^#(::(@x, @xs), @l2) -> c_17(zipWithOr#2^#(@l2, @x, @xs)) , zipWithOr#2^#(::(@y, @ys), @x, @xs) -> c_27(zipWithOr^#(@xs, @ys)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , length^#(@l) -> c_3(length#1^#(@l)) , zipWithAnd^#(@l1, @l2) -> c_5(zipWithAnd#1^#(@l1, @l2)) } Weak DPs: { append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#8^#(@s) , bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_18(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_26(zipWithAnd^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 8: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , 15: bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , 16: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , 19: zipWithAnd#1^#(::(@x, @xs), @l2) -> c_18(zipWithAnd#2^#(@l2, @x, @xs)) , 26: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) } Trs: { append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(nil(), @x, @xs) -> nil() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_5) = {1}, Uargs(c_10) = {1}, Uargs(c_15) = {1}, Uargs(c_18) = {1}, Uargs(c_26) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [+](x1, x2) = [1] x2 + [0] [#add](x1, x2) = [1] x2 + [0] [and](x1, x2) = [0] [#and](x1, x2) = [1] x1 + [1] x2 + [0] [append](x1, x2) = [0] [append#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x2 + [1] [append#2](x1, x2) = [0] [nil] = [0] [bitonicMerge](x1, x2) = [0] [bitonicMerge#1](x1, x2, x3) = [1] x1 + [1] x3 + [0] [bitonicMerge#2](x1, x2, x3) = [1] x3 + [1] [#false] = [0] [bitonicMerge#10](x1, x2, x3) = [0] [tuple#2](x1, x2) = [1] x1 + [0] [#true] = [0] [length](x1) = [0] [div2](x1) = [1] x1 + [0] [bitonicMerge#3](x1, x2, x3) = [0] [splitAt](x1, x2) = [1] x1 + [0] [bitonicMerge#4](x1, x2) = [0] [bitonicMerge#6](x1) = [0] [bitonicMerge#5](x1, x2, x3) = [1] x1 + [0] [bitonicMerge#8](x1) = [1] x1 + [0] [bitonicMerge#7](x1, x2, x3) = [1] x1 + [0] [zipWithOr](x1, x2) = [0] [bitonicMerge#9](x1, x2) = [1] x1 + [0] [zipWithAnd](x1, x2) = [1] x1 + [0] [bitonicSort](x1, x2) = [0] [bitonicSort#1](x1, x2, x3) = [1] [split](x1) = [0] [bitonicSort#2](x1, x2) = [0] [bitonicSort#3](x1, x2, x3, x4) = [0] [bitonicSort#4](x1, x2, x3, x4) = [0] [div2#1](x1) = [1] x1 + [0] [#0] = [0] [#s](x1) = [1] x1 + [1] [div2#2](x1) = [1] x1 + [0] [#pos](x1) = [0] [length#1](x1) = [0] [or](x1, x2) = [0] [#or](x1, x2) = [1] x1 + [1] x2 + [0] [split#1](x1) = [0] [split#2](x1, x2) = [0] [split#3](x1, x2, x3) = [0] [splitAt#1](x1, x2) = [1] x1 + [0] [splitAt#2](x1, x2) = [1] x2 + [1] [splitAt#3](x1, x2) = [1] x1 + [1] [zipWithAnd#1](x1, x2) = [1] x1 + [0] [zipWithAnd#2](x1, x2, x3) = [1] x3 + [1] [zipWithOr#1](x1, x2) = [1] [zipWithOr#2](x1, x2, x3) = [1] [#neg](x1) = [0] [#pred](x1) = [1] x1 + [0] [#succ](x1) = [1] x1 + [0] [+^#](x1, x2) = [0] [#add^#](x1, x2) = [0] [and^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [append^#](x1, x2) = [0] [append#1^#](x1, x2) = [0] [append#2^#](x1, x2) = [0] [bitonicMerge^#](x1, x2) = [1] [bitonicMerge#1^#](x1, x2, x3) = [1] [bitonicMerge#2^#](x1, x2, x3) = [1] [bitonicMerge#3^#](x1, x2, x3) = [1] x1 + [1] [div2^#](x1) = [0] [length^#](x1) = [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [length#1^#](x1) = [0] [div2#1^#](x1) = [0] [bitonicMerge#4^#](x1, x2) = [1] x1 + [1] [splitAt^#](x1, x2) = [0] [splitAt#1^#](x1, x2) = [0] [bitonicMerge#5^#](x1, x2, x3) = [1] x3 + [1] [bitonicMerge#6^#](x1) = [0] [zipWithOr^#](x1, x2) = [0] [bitonicMerge#7^#](x1, x2, x3) = [1] x1 + [1] [bitonicMerge#8^#](x1) = [1] x1 + [1] [zipWithAnd^#](x1, x2) = [1] x1 + [0] [bitonicMerge#9^#](x1, x2) = [1] [zipWithOr#1^#](x1, x2) = [0] [zipWithAnd#1^#](x1, x2) = [1] x1 + [0] [bitonicSort^#](x1, x2) = [1] [bitonicSort#1^#](x1, x2, x3) = [1] [bitonicSort#2^#](x1, x2) = [1] [split^#](x1) = [0] [split#1^#](x1) = [0] [bitonicSort#3^#](x1, x2, x3, x4) = [1] [bitonicSort#4^#](x1, x2, x3, x4) = [1] [div2#2^#](x1) = [0] [or^#](x1, x2) = [0] [#or^#](x1, x2) = [0] [split#2^#](x1, x2) = [0] [split#3^#](x1, x2, x3) = [0] [splitAt#2^#](x1, x2) = [0] [splitAt#3^#](x1, x2) = [0] [zipWithAnd#2^#](x1, x2, x3) = [1] x3 + [0] [zipWithOr#2^#](x1, x2, x3) = [0] [#succ^#](x1) = [0] [#pred^#](x1) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [0] [c_5](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] [c_13](x1) = [0] [c_15](x1) = [1] x1 + [0] [c_17](x1) = [0] [c_18](x1) = [1] x1 + [0] [c_26](x1) = [1] x1 + [0] [c_27](x1) = [0] This order satisfies following ordering constraints [+(@x, @y)] = [1] @y + [0] >= [1] @y + [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1] @y + [0] >= [1] @y + [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1] @y + [0] >= [1] @y + [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1] @y + [0] >= [1] @y + [0] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1] @y + [0] >= [1] @y + [0] = [#pred(#add(#pos(#s(@x)), @y))] [length(@l)] = [0] >= [0] = [length#1(@l)] [div2(@n)] = [1] @n + [0] >= [1] @n + [0] = [div2#1(@n)] [splitAt(@n, @l)] = [1] @n + [0] >= [1] @n + [0] = [splitAt#1(@n, @l)] [bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [1] @zipWithAnd@3 + [0] >= [1] @zipWithAnd@3 + [0] = [zipWithAnd(@zipWithAnd@3, @zipWithAnd@4)] [zipWithAnd(@l1, @l2)] = [1] @l1 + [0] >= [1] @l1 + [0] = [zipWithAnd#1(@l1, @l2)] [div2#1(#0())] = [0] >= [0] = [#0()] [div2#1(#s(@n))] = [1] @n + [1] > [1] @n + [0] = [div2#2(@n)] [div2#2(#0())] = [0] >= [0] = [#0()] [div2#2(#s(@n))] = [1] @n + [1] > [1] @n + [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [0] >= [0] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [0] >= [0] = [#0()] [splitAt#1(#0(), @l)] = [0] >= [0] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [1] @n' + [1] >= [1] @n' + [1] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [1] @n' + [1] >= [1] @n' + [1] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [1] @n' + [1] > [0] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [1] @l1 + [1] >= [1] @l1 + [1] = [tuple#2(::(@x, @l1), @l2)] [zipWithAnd#1(::(@x, @xs), @l2)] = [1] @xs + [1] >= [1] @xs + [1] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [0] >= [0] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [1] @xs + [1] >= [1] @xs + [1] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [1] @xs + [1] > [0] = [nil()] [#pred(#0())] = [0] >= [0] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [0] >= [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [0] >= [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [0] >= [0] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] >= [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] >= [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [0] >= [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [0] >= [0] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] >= [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] >= [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [1] >= [1] = [bitonicMerge#1^#(@l, @direction, @l)] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [1] >= [1] = [bitonicMerge#2^#(@xs, @direction, @l)] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [1] >= [1] = [bitonicMerge#3^#(div2(length(@l)), @direction, @l)] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [1] > [0] = [length^#(@l)] [bitonicMerge#3^#(@h, @direction, @l)] = [1] @h + [1] >= [1] @h + [1] = [bitonicMerge#4^#(splitAt(@h, @l), @direction)] [length^#(@l)] = [0] >= [0] = [c_3(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0] >= [0] = [c_10(length^#(@xs))] [bitonicMerge#4^#(@s, @direction)] = [1] @s + [1] >= [1] @s + [1] = [bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s)] [bitonicMerge#5^#(@hi, @direction, @s)] = [1] @s + [1] >= [1] @s + [1] = [bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi)] [bitonicMerge#5^#(@hi, @direction, @s)] = [1] @s + [1] >= [1] @s + [1] = [bitonicMerge#8^#(@s)] [bitonicMerge#7^#(@low, @direction, @hi)] = [1] @low + [1] >= [1] = [bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)] [bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [1] @zipWithAnd@3 + [1] > [1] @zipWithAnd@3 + [0] = [c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4))] [zipWithAnd^#(@l1, @l2)] = [1] @l1 + [0] >= [1] @l1 + [0] = [c_5(zipWithAnd#1^#(@l1, @l2))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1] > [0] = [append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1] >= [1] = [bitonicMerge^#(@hi, @direction)] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1] >= [1] = [bitonicMerge^#(@low, @direction)] [zipWithAnd#1^#(::(@x, @xs), @l2)] = [1] @xs + [1] > [1] @xs + [0] = [c_18(zipWithAnd#2^#(@l2, @x, @xs))] [bitonicSort^#(@l, @dir)] = [1] >= [1] = [bitonicSort#1^#(@l, @dir, @l)] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [1] >= [1] = [bitonicSort#2^#(split(@l), @dir)] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [1] >= [1] = [bitonicSort^#(@l1, #true())] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [1] >= [1] = [bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [1] >= [1] = [bitonicSort^#(@l2, #false())] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [1] >= [1] = [bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [1] > [0] = [append^#(@l1, @l2)] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [1] >= [1] = [bitonicMerge^#(append(@l1, @l2), @dir)] [zipWithAnd#2^#(::(@y, @ys), @x, @xs)] = [1] @xs + [0] >= [1] @xs + [0] = [c_26(zipWithAnd^#(@xs, @ys))] Consider the set of all dependency pairs DPs: { 1: append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , 2: length^#(@l) -> c_3(length#1^#(@l)) , 3: zipWithAnd^#(@l1, @l2) -> c_5(zipWithAnd#1^#(@l1, @l2)) , 4: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , 5: bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , 6: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , 7: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , 8: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , 9: bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , 10: length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) , 11: bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , 12: bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , 13: bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#8^#(@s) , 14: bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , 15: bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , 16: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , 17: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , 18: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , 19: zipWithAnd#1^#(::(@x, @xs), @l2) -> c_18(zipWithAnd#2^#(@l2, @x, @xs)) , 20: bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , 21: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , 22: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , 23: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , 24: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , 25: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , 26: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , 27: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) , 28: zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_26(zipWithAnd^#(@xs, @ys)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {8,15,16,19,26}. These cover all (indirect) predecessors of dependency pairs {3,8,15,16,19,26,28}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , length^#(@l) -> c_3(length#1^#(@l)) } Weak DPs: { append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#8^#(@s) , bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_5(zipWithAnd#1^#(@l1, @l2)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_18(zipWithAnd#2^#(@l2, @x, @xs)) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_26(zipWithAnd^#(@xs, @ys)) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#8^#(@s) , bitonicMerge#8^#(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> c_15(zipWithAnd^#(@zipWithAnd@3, @zipWithAnd@4)) , zipWithAnd^#(@l1, @l2) -> c_5(zipWithAnd#1^#(@l1, @l2)) , zipWithAnd#1^#(::(@x, @xs), @l2) -> c_18(zipWithAnd#2^#(@l2, @x, @xs)) , zipWithAnd#2^#(::(@y, @ys), @x, @xs) -> c_26(zipWithAnd^#(@xs, @ys)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , length^#(@l) -> c_3(length#1^#(@l)) } Weak DPs: { append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 2: length^#(@l) -> c_3(length#1^#(@l)) , 13: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , 22: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , 23: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) } Trs: { #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(nil(), @direction, @l) -> @l , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_10) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [+](x1, x2) = [2 0] x1 + [1 0] x2 + [0] [0 2] [0 1] [0] [#add](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [and](x1, x2) = [0 0] x1 + [0] [0 1] [0] [#and](x1, x2) = [0 0] x1 + [1] [0 1] [0] [append](x1, x2) = [0 0] x1 + [2 2] x2 + [0] [0 1] [1 1] [0] [append#1](x1, x2) = [0 0] x1 + [2 2] x2 + [0] [0 1] [1 1] [0] [::](x1, x2) = [1 0] x2 + [0] [0 1] [1] [append#2](x1, x2) = [1 0] x1 + [0] [0 1] [1] [nil] = [0] [0] [bitonicMerge](x1, x2) = [1 0] x1 + [0 2] x2 + [2] [1 1] [0 0] [0] [bitonicMerge#1](x1, x2, x3) = [2 0] x2 + [1 0] x3 + [2] [2 2] [0 1] [2] [bitonicMerge#2](x1, x2, x3) = [2 0] x2 + [2 0] x3 + [2] [2 2] [2 2] [2] [#false] = [0] [0] [bitonicMerge#10](x1, x2, x3) = [1 1] x2 + [1 1] x3 + [1] [0 2] [0 2] [2] [tuple#2](x1, x2) = [0 1] x1 + [1 1] x2 + [1] [0 1] [0 0] [0] [#true] = [0] [0] [length](x1) = [0] [2] [div2](x1) = [2 0] x1 + [0] [0 0] [0] [bitonicMerge#3](x1, x2, x3) = [0 2] x1 + [2 0] x2 + [2] [0 0] [2 2] [2] [splitAt](x1, x2) = [0 2] x1 + [1 1] x2 + [1] [0 1] [0 0] [0] [bitonicMerge#4](x1, x2) = [0 0] x1 + [1 0] x2 + [2] [1 2] [0 1] [2] [bitonicMerge#6](x1) = [0 0] x1 + [0] [0 1] [0] [bitonicMerge#5](x1, x2, x3) = [1 0] x1 + [2 0] x2 + [2] [2 2] [2 2] [0] [bitonicMerge#8](x1) = [0 0] x1 + [0] [0 1] [0] [bitonicMerge#7](x1, x2, x3) = [0 0] x1 + [2 0] x2 + [2 0] x3 + [2] [1 1] [0 2] [2 2] [0] [zipWithOr](x1, x2) = [0 0] x1 + [0] [0 1] [0] [bitonicMerge#9](x1, x2) = [0 0] x1 + [0 0] x2 + [1] [2 0] [0 2] [2] [zipWithAnd](x1, x2) = [0 0] x1 + [0] [0 1] [0] [bitonicSort](x1, x2) = [0 0] x1 + [0] [0 1] [0] [bitonicSort#1](x1, x2, x3) = [0] [0] [split](x1) = [0 1] x1 + [1] [1 2] [2] [bitonicSort#2](x1, x2) = [2 0] x2 + [0] [0 2] [0] [bitonicSort#3](x1, x2, x3, x4) = [2 0] x2 + [2 0] x4 + [0] [2 2] [0 0] [0] [bitonicSort#4](x1, x2, x3, x4) = [2 0] x2 + [2 0] x3 + [0] [2 2] [2 2] [0] [div2#1](x1) = [2 0] x1 + [0] [0 0] [0] [#0] = [0] [0] [#s](x1) = [1 0] x1 + [0] [0 1] [2] [div2#2](x1) = [2 0] x1 + [0] [0 0] [0] [#pos](x1) = [0] [0] [length#1](x1) = [0] [2] [or](x1, x2) = [0 0] x2 + [2] [0 1] [1] [#or](x1, x2) = [0 0] x2 + [2] [0 1] [0] [split#1](x1) = [0 1] x1 + [1] [1 2] [2] [split#2](x1, x2) = [0 1] x1 + [2] [1 2] [2] [split#3](x1, x2, x3) = [1 0] x1 + [2] [0 1] [1] [splitAt#1](x1, x2) = [0 2] x1 + [1 1] x2 + [1] [0 1] [0 0] [0] [splitAt#2](x1, x2) = [1 1] x1 + [0 2] x2 + [2] [0 0] [0 1] [2] [splitAt#3](x1, x2) = [1 0] x1 + [2] [0 1] [1] [zipWithAnd#1](x1, x2) = [0 0] x1 + [0] [0 1] [0] [zipWithAnd#2](x1, x2, x3) = [0 0] x3 + [0] [0 1] [1] [zipWithOr#1](x1, x2) = [0 0] x1 + [0] [0 1] [0] [zipWithOr#2](x1, x2, x3) = [0 0] x3 + [0] [0 1] [1] [#neg](x1) = [2] [2] [#pred](x1) = [1 0] x1 + [2] [0 1] [2] [#succ](x1) = [1 0] x1 + [0] [0 1] [0] [+^#](x1, x2) = [0] [0] [#add^#](x1, x2) = [0] [0] [and^#](x1, x2) = [0] [0] [#and^#](x1, x2) = [0] [0] [append^#](x1, x2) = [0] [0] [append#1^#](x1, x2) = [0] [0] [append#2^#](x1, x2) = [0] [0] [bitonicMerge^#](x1, x2) = [0 1] x1 + [1 2] x2 + [1] [0 0] [0 0] [1] [bitonicMerge#1^#](x1, x2, x3) = [1 2] x2 + [0 1] x3 + [1] [0 0] [0 0] [1] [bitonicMerge#2^#](x1, x2, x3) = [1 2] x2 + [0 1] x3 + [1] [0 0] [0 0] [1] [bitonicMerge#3^#](x1, x2, x3) = [0 2] x1 + [1 2] x2 + [0 1] x3 + [1] [2 1] [0 0] [0 0] [1] [div2^#](x1) = [0] [0] [length^#](x1) = [0 1] x1 + [1] [0 0] [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [0] [length#1^#](x1) = [0 1] x1 + [0] [0 0] [0] [div2#1^#](x1) = [0] [0] [bitonicMerge#4^#](x1, x2) = [0 2] x1 + [1 2] x2 + [1] [0 1] [0 0] [1] [splitAt^#](x1, x2) = [0] [0] [splitAt#1^#](x1, x2) = [0] [0] [bitonicMerge#5^#](x1, x2, x3) = [2 1] x1 + [1 2] x2 + [0 1] x3 + [1] [0 1] [0 0] [0 0] [1] [bitonicMerge#6^#](x1) = [0] [0] [zipWithOr^#](x1, x2) = [0] [0] [bitonicMerge#7^#](x1, x2, x3) = [1 1] x1 + [1 2] x2 + [2 1] x3 + [1] [0 0] [0 0] [0 0] [1] [bitonicMerge#8^#](x1) = [0] [0] [zipWithAnd^#](x1, x2) = [0] [0] [bitonicMerge#9^#](x1, x2) = [1 0] x1 + [1 2] x2 + [0] [0 0] [0 0] [1] [zipWithOr#1^#](x1, x2) = [0] [0] [zipWithAnd#1^#](x1, x2) = [0] [0] [bitonicSort^#](x1, x2) = [0 1] x1 + [1 2] x2 + [2] [0 0] [0 0] [1] [bitonicSort#1^#](x1, x2, x3) = [1 2] x2 + [0 1] x3 + [2] [0 0] [0 0] [1] [bitonicSort#2^#](x1, x2) = [1 0] x1 + [1 2] x2 + [1] [0 0] [0 0] [1] [split^#](x1) = [0] [0] [split#1^#](x1) = [0] [0] [bitonicSort#3^#](x1, x2, x3, x4) = [1 2] x2 + [0 1] x3 + [1 1] x4 + [2] [0 0] [0 0] [0 0] [1] [bitonicSort#4^#](x1, x2, x3, x4) = [1 2] x2 + [0 1] x3 + [1 1] x4 + [2] [0 0] [0 0] [0 0] [1] [div2#2^#](x1) = [0] [0] [or^#](x1, x2) = [0] [0] [#or^#](x1, x2) = [0] [0] [split#2^#](x1, x2) = [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [splitAt#2^#](x1, x2) = [0] [0] [splitAt#3^#](x1, x2) = [0] [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [0] [zipWithOr#2^#](x1, x2, x3) = [0] [0] [#succ^#](x1) = [0] [0] [#pred^#](x1) = [0] [0] [c_1](x1) = [1 1] x1 + [0] [0 0] [0] [c_2](x1) = [1 0] x1 + [0] [0 0] [0] [c_3](x1) = [1 0] x1 + [0] [0 0] [0] [c_4](x1) = [0] [0] [c_5](x1) = [0] [0] [c_10](x1) = [1 0] x1 + [0] [0 0] [0] [c_13](x1) = [0] [0] [c_15](x1) = [0] [0] [c_17](x1) = [0] [0] [c_18](x1) = [0] [0] [c_26](x1) = [0] [0] [c_27](x1) = [0] [0] This order satisfies following ordering constraints [+(@x, @y)] = [2 0] @x + [1 0] @y + [0] [0 2] [0 1] [0] >= [1 0] @x + [1 0] @y + [0] [0 1] [0 1] [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1 0] @y + [0] [0 1] [0] >= [1 0] @y + [0] [0 1] [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1 0] @y + [0] [0 1] [0] >= [1 0] @y + [0] [0 1] [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1 0] @y + [0] [0 1] [0] >= [1 0] @y + [0] [0 1] [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1 0] @y + [2] [0 1] [2] >= [1 0] @y + [2] [0 1] [2] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1 0] @y + [2] [0 1] [2] >= [1 0] @y + [2] [0 1] [2] = [#pred(#add(#pos(#s(@x)), @y))] [append(@l, @ys)] = [0 0] @l + [2 2] @ys + [0] [0 1] [1 1] [0] >= [0 0] @l + [2 2] @ys + [0] [0 1] [1 1] [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [0 0] @xs + [2 2] @ys + [0] [0 1] [1 1] [1] >= [0 0] @xs + [2 2] @ys + [0] [0 1] [1 1] [1] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [2 2] @ys + [0] [1 1] [0] >= [1 0] @ys + [0] [0 1] [0] = [@ys] [append#2(@l', @x)] = [1 0] @l' + [0] [0 1] [1] >= [1 0] @l' + [0] [0 1] [1] = [::(@x, @l')] [bitonicMerge#10(#false(), @hi, @low)] = [1 1] @hi + [1 1] @low + [1] [0 2] [0 2] [2] >= [1 1] @hi + [0 1] @low + [1] [0 0] [0 1] [0] = [tuple#2(@low, @hi)] [bitonicMerge#10(#true(), @hi, @low)] = [1 1] @hi + [1 1] @low + [1] [0 2] [0 2] [2] >= [0 1] @hi + [1 1] @low + [1] [0 1] [0 0] [0] = [tuple#2(@hi, @low)] [length(@l)] = [0] [2] >= [0] [2] = [length#1(@l)] [div2(@n)] = [2 0] @n + [0] [0 0] [0] >= [2 0] @n + [0] [0 0] [0] = [div2#1(@n)] [splitAt(@n, @l)] = [1 1] @l + [0 2] @n + [1] [0 0] [0 1] [0] >= [1 1] @l + [0 2] @n + [1] [0 0] [0 1] [0] = [splitAt#1(@n, @l)] [bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [0 0] @zipWithOr@1 + [0] [0 1] [0] >= [0 0] @zipWithOr@1 + [0] [0 1] [0] = [zipWithOr(@zipWithOr@1, @zipWithOr@2)] [bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [0 0] @zipWithAnd@3 + [0] [0 1] [0] >= [0 0] @zipWithAnd@3 + [0] [0 1] [0] = [zipWithAnd(@zipWithAnd@3, @zipWithAnd@4)] [zipWithOr(@l1, @l2)] = [0 0] @l1 + [0] [0 1] [0] >= [0 0] @l1 + [0] [0 1] [0] = [zipWithOr#1(@l1, @l2)] [zipWithAnd(@l1, @l2)] = [0 0] @l1 + [0] [0 1] [0] >= [0 0] @l1 + [0] [0 1] [0] = [zipWithAnd#1(@l1, @l2)] [split(@l)] = [0 1] @l + [1] [1 2] [2] >= [0 1] @l + [1] [1 2] [2] = [split#1(@l)] [div2#1(#0())] = [0] [0] >= [0] [0] = [#0()] [div2#1(#s(@n))] = [2 0] @n + [0] [0 0] [0] >= [2 0] @n + [0] [0 0] [0] = [div2#2(@n)] [div2#2(#0())] = [0] [0] >= [0] [0] = [#0()] [div2#2(#s(@n))] = [2 0] @n + [0] [0 0] [0] >= [2 0] @n + [0] [0 0] [0] = [+(#pos(#s(#0())), div2(@n))] [length#1(::(@x, @xs))] = [0] [2] >= [0] [2] = [+(#pos(#s(#0())), length(@xs))] [length#1(nil())] = [0] [2] >= [0] [0] = [#0()] [split#1(::(@x1, @xs))] = [0 1] @xs + [2] [1 2] [4] >= [0 1] @xs + [2] [1 2] [2] = [split#2(@xs, @x1)] [split#1(nil())] = [1] [2] >= [1] [0] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [0 1] @xs' + [3] [1 2] [4] >= [0 1] @xs' + [3] [1 2] [3] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [2] [2] > [1] [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [0 1] @l1 + [1 1] @l2 + [3] [0 1] [0 0] [1] >= [0 1] @l1 + [1 1] @l2 + [3] [0 1] [0 0] [1] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [splitAt#1(#0(), @l)] = [1 1] @l + [1] [0 0] [0] >= [1 1] @l + [1] [0 0] [0] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [1 1] @l + [0 2] @n' + [5] [0 0] [0 1] [2] > [1 1] @l + [0 2] @n' + [2] [0 0] [0 1] [2] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [0 2] @n' + [1 1] @xs + [3] [0 1] [0 0] [2] >= [0 2] @n' + [1 1] @xs + [3] [0 1] [0 0] [1] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [0 2] @n' + [2] [0 1] [2] > [1] [0] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [0 1] @l1 + [1 1] @l2 + [3] [0 1] [0 0] [1] > [0 1] @l1 + [1 1] @l2 + [2] [0 1] [0 0] [1] = [tuple#2(::(@x, @l1), @l2)] [zipWithAnd#1(::(@x, @xs), @l2)] = [0 0] @xs + [0] [0 1] [1] >= [0 0] @xs + [0] [0 1] [1] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [0] [0] >= [0] [0] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [0 0] @xs + [0] [0 1] [1] >= [0 0] @xs + [0] [0 1] [1] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [0 0] @xs + [0] [0 1] [1] >= [0] [0] = [nil()] [zipWithOr#1(::(@x, @xs), @l2)] = [0 0] @xs + [0] [0 1] [1] >= [0 0] @xs + [0] [0 1] [1] = [zipWithOr#2(@l2, @x, @xs)] [zipWithOr#1(nil(), @l2)] = [0] [0] >= [0] [0] = [nil()] [zipWithOr#2(::(@y, @ys), @x, @xs)] = [0 0] @xs + [0] [0 1] [1] >= [0 0] @xs + [0] [0 1] [1] = [::(or(@x, @y), zipWithOr(@xs, @ys))] [zipWithOr#2(nil(), @x, @xs)] = [0 0] @xs + [0] [0 1] [1] >= [0] [0] = [nil()] [#pred(#0())] = [2] [2] >= [2] [2] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [2] [2] > [0] [0] = [#0()] [#pred(#pos(#s(#s(@x))))] = [2] [2] > [0] [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [4] [4] > [2] [2] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] [0] >= [0] [0] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0] [0] >= [0] [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [2] [2] > [0] [0] = [#0()] [#succ(#neg(#s(#s(@x))))] = [2] [2] >= [2] [2] = [#neg(#s(@x))] [append^#(@l, @ys)] = [0] [0] >= [0] [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [0] [0] >= [0] [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [1 2] @direction + [0 1] @l + [1] [0 0] [0 0] [1] >= [1 2] @direction + [0 1] @l + [1] [0 0] [0 0] [1] = [bitonicMerge#1^#(@l, @direction, @l)] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [1 2] @direction + [0 1] @l + [1] [0 0] [0 0] [1] >= [1 2] @direction + [0 1] @l + [1] [0 0] [0 0] [1] = [bitonicMerge#2^#(@xs, @direction, @l)] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [1 2] @direction + [0 1] @l + [1] [0 0] [0 0] [1] >= [1 2] @direction + [0 1] @l + [1] [0 0] [0 0] [1] = [bitonicMerge#3^#(div2(length(@l)), @direction, @l)] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [1 2] @direction + [0 1] @l + [1] [0 0] [0 0] [1] >= [0 1] @l + [1] [0 0] [0] = [length^#(@l)] [bitonicMerge#3^#(@h, @direction, @l)] = [1 2] @direction + [0 2] @h + [0 1] @l + [1] [0 0] [2 1] [0 0] [1] >= [1 2] @direction + [0 2] @h + [1] [0 0] [0 1] [1] = [bitonicMerge#4^#(splitAt(@h, @l), @direction)] [length^#(@l)] = [0 1] @l + [1] [0 0] [0] > [0 1] @l + [0] [0 0] [0] = [c_3(length#1^#(@l))] [length#1^#(::(@x, @xs))] = [0 1] @xs + [1] [0 0] [0] >= [0 1] @xs + [1] [0 0] [0] = [c_10(length^#(@xs))] [bitonicMerge#4^#(@s, @direction)] = [1 2] @direction + [0 2] @s + [1] [0 0] [0 1] [1] >= [1 2] @direction + [0 2] @s + [1] [0 0] [0 1] [1] = [bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s)] [bitonicMerge#5^#(@hi, @direction, @s)] = [1 2] @direction + [2 1] @hi + [0 1] @s + [1] [0 0] [0 1] [0 0] [1] >= [1 2] @direction + [2 1] @hi + [0 1] @s + [1] [0 0] [0 0] [0 0] [1] = [bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi)] [bitonicMerge#7^#(@low, @direction, @hi)] = [1 2] @direction + [2 1] @hi + [1 1] @low + [1] [0 0] [0 0] [0 0] [1] >= [1 2] @direction + [1 1] @hi + [1 1] @low + [1] [0 0] [0 0] [0 0] [1] = [bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1 2] @direction + [0 1] @hi + [1 1] @low + [1] [0 0] [0 0] [0 0] [1] > [0] [0] = [append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1 2] @direction + [0 1] @hi + [1 1] @low + [1] [0 0] [0 0] [0 0] [1] >= [1 2] @direction + [0 1] @hi + [1] [0 0] [0 0] [1] = [bitonicMerge^#(@hi, @direction)] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1 2] @direction + [0 1] @hi + [1 1] @low + [1] [0 0] [0 0] [0 0] [1] >= [1 2] @direction + [0 1] @low + [1] [0 0] [0 0] [1] = [bitonicMerge^#(@low, @direction)] [bitonicSort^#(@l, @dir)] = [1 2] @dir + [0 1] @l + [2] [0 0] [0 0] [1] >= [1 2] @dir + [0 1] @l + [2] [0 0] [0 0] [1] = [bitonicSort#1^#(@l, @dir, @l)] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [1 2] @dir + [0 1] @l + [2] [0 0] [0 0] [1] >= [1 2] @dir + [0 1] @l + [2] [0 0] [0 0] [1] = [bitonicSort#2^#(split(@l), @dir)] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [1 2] @dir + [0 1] @l1 + [1 1] @l2 + [2] [0 0] [0 0] [0 0] [1] >= [0 1] @l1 + [2] [0 0] [1] = [bitonicSort^#(@l1, #true())] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [1 2] @dir + [0 1] @l1 + [1 1] @l2 + [2] [0 0] [0 0] [0 0] [1] >= [1 2] @dir + [0 1] @l1 + [1 1] @l2 + [2] [0 0] [0 0] [0 0] [1] = [bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [1 2] @dir + [0 1] @l1 + [1 1] @l2 + [2] [0 0] [0 0] [0 0] [1] >= [0 1] @l2 + [2] [0 0] [1] = [bitonicSort^#(@l2, #false())] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [1 2] @dir + [0 1] @l1 + [1 1] @l2 + [2] [0 0] [0 0] [0 0] [1] >= [1 2] @dir + [0 1] @l1 + [1 1] @l2 + [2] [0 0] [0 0] [0 0] [1] = [bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [1 2] @dir + [0 1] @l1 + [1 1] @l2 + [2] [0 0] [0 0] [0 0] [1] > [0] [0] = [append^#(@l1, @l2)] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [1 2] @dir + [0 1] @l1 + [1 1] @l2 + [2] [0 0] [0 0] [0 0] [1] > [1 2] @dir + [0 1] @l1 + [1 1] @l2 + [1] [0 0] [0 0] [0 0] [1] = [bitonicMerge^#(append(@l1, @l2), @dir)] Consider the set of all dependency pairs DPs: { 1: append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , 2: length^#(@l) -> c_3(length#1^#(@l)) , 3: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , 4: bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , 5: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , 6: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , 7: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , 8: bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , 9: length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) , 10: bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , 11: bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , 12: bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , 13: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , 14: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , 15: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , 16: bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , 17: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , 18: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , 19: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , 20: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , 21: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , 22: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , 23: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {2,13,22,23}. These cover all (indirect) predecessors of dependency pairs {2,9,13,22,23}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) } Weak DPs: { append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , length^#(@l) -> c_3(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> length^#(@l) , length^#(@l) -> c_3(length#1^#(@l)) , length#1^#(::(@x, @xs)) -> c_10(length^#(@xs)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) } Weak DPs: { append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 3' to orient following rules strictly. DPs: { 2: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , 10: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , 19: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) } Trs: { #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [1 0 0] [1 0 0] [0] [+](x1, x2) = [1 1 0] x1 + [1 1 0] x2 + [0] [1 0 0] [1 0 1] [0] [1 0 0] [1 0 0] [0] [#add](x1, x2) = [1 0 0] x1 + [0 1 0] x2 + [0] [1 0 0] [0 0 1] [0] [0] [and](x1, x2) = [0] [1] [0] [#and](x1, x2) = [0] [0] [1 0 0] [1 0 0] [0] [append](x1, x2) = [0 0 0] x1 + [0 1 0] x2 + [0] [0 0 0] [0 0 1] [0] [1 0 0] [1 0 0] [0] [append#1](x1, x2) = [0 0 0] x1 + [0 1 0] x2 + [0] [0 0 0] [0 0 1] [0] [1 0 0] [1] [::](x1, x2) = [0 0 0] x2 + [0] [0 0 0] [0] [1 0 0] [1] [append#2](x1, x2) = [0 0 0] x1 + [0] [0 0 0] [0] [0] [nil] = [0] [0] [1 0 0] [0 0 0] [0] [bitonicMerge](x1, x2) = [1 1 0] x1 + [1 1 1] x2 + [1] [1 1 1] [1 1 1] [1] [0 0 0] [0 0 0] [1 0 0] [0] [bitonicMerge#1](x1, x2, x3) = [0 0 0] x1 + [1 1 1] x2 + [1 1 0] x3 + [1] [0 1 0] [1 1 1] [1 0 1] [1] [0 0 0] [1 0 0] [0] [bitonicMerge#2](x1, x2, x3) = [1 1 1] x2 + [1 1 0] x3 + [1] [1 1 1] [1 0 1] [1] [1] [#false] = [1] [1] [1 0 0] [1 0 0] [0] [bitonicMerge#10](x1, x2, x3) = [0 1 1] x2 + [0 1 1] x3 + [1] [1 0 0] [1 0 0] [0] [1 0 0] [0 0 0] [0] [tuple#2](x1, x2) = [0 1 1] x1 + [0 0 0] x2 + [1] [1 0 0] [1 0 0] [0] [1] [#true] = [1] [1] [0 0 0] [1] [length](x1) = [0 1 0] x1 + [1] [0 0 0] [0] [0] [div2](x1) = [1] [1] [1 0 0] [0 0 0] [1 0 0] [0] [bitonicMerge#3](x1, x2, x3) = [1 0 0] x1 + [1 1 1] x2 + [1 0 0] x3 + [1] [1 0 0] [1 1 1] [1 0 1] [1] [1 0 0] [0 0 0] [0] [splitAt](x1, x2) = [1 0 1] x1 + [0 0 0] x2 + [0] [0 0 0] [1 0 0] [0] [1 0 1] [0 0 0] [0] [bitonicMerge#4](x1, x2) = [1 0 1] x1 + [1 1 1] x2 + [1] [1 0 1] [1 1 1] [1] [0 0 1] [0] [bitonicMerge#6](x1) = [0 0 0] x1 + [0] [0 0 0] [0] [1 0 0] [0 0 0] [1 0 0] [0] [bitonicMerge#5](x1, x2, x3) = [1 1 1] x1 + [1 1 1] x2 + [1 0 0] x3 + [1] [1 1 1] [1 1 1] [1 0 0] [1] [1 0 0] [0] [bitonicMerge#8](x1) = [0 0 0] x1 + [0] [0 0 0] [0] [1 0 0] [0 0 0] [1 0 0] [0] [bitonicMerge#7](x1, x2, x3) = [1 1 1] x1 + [1 1 1] x2 + [1 1 1] x3 + [1] [1 1 1] [1 1 1] [1 1 1] [1] [1 0 0] [0] [zipWithOr](x1, x2) = [0 0 0] x1 + [0] [0 0 0] [0] [0 0 1] [0 0 0] [0] [bitonicMerge#9](x1, x2) = [1 1 0] x1 + [1 1 1] x2 + [0] [1 1 0] [1 1 1] [0] [1 0 0] [0] [zipWithAnd](x1, x2) = [0 0 0] x1 + [0] [0 0 0] [0] [1 0 0] [1] [bitonicSort](x1, x2) = [0 0 0] x1 + [0] [1 0 1] [0] [1] [bitonicSort#1](x1, x2, x3) = [0] [0] [1 0 0] [1] [split](x1) = [0 0 0] x1 + [1] [1 0 0] [0] [0 0 0] [0] [bitonicSort#2](x1, x2) = [0 0 0] x2 + [0] [0 0 1] [0] [0 0 0] [0 0 0] [1 0 0] [0 0 0] [1] [bitonicSort#3](x1, x2, x3, x4) = [0 0 0] x1 + [1 0 0] x2 + [0 0 0] x3 + [0 1 0] x4 + [0] [0 0 1] [0 0 0] [1 0 1] [0 0 0] [0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1] [bitonicSort#4](x1, x2, x3, x4) = [0 0 0] x1 + [0 0 0] x2 + [0 0 0] x3 + [0 0 0] x4 + [0] [0 0 1] [1 0 0] [0 1 0] [0 0 1] [0] [0] [div2#1](x1) = [1] [1] [0] [#0] = [0] [1] [1 0 0] [1] [#s](x1) = [0 0 0] x1 + [0] [0 0 1] [0] [0] [div2#2](x1) = [1] [1] [0 0 0] [0] [#pos](x1) = [0 1 0] x1 + [0] [0 0 1] [0] [0 0 0] [1] [length#1](x1) = [0 1 0] x1 + [1] [0 0 0] [0] [0] [or](x1, x2) = [1] [0] [0] [#or](x1, x2) = [0] [0] [1 0 0] [0] [split#1](x1) = [0 0 0] x1 + [1] [1 0 0] [0] [1 0 0] [0] [split#2](x1, x2) = [0 0 0] x1 + [1] [1 0 0] [1] [0 0 1] [1] [split#3](x1, x2, x3) = [0 1 0] x1 + [0] [0 1 1] [1] [1 0 0] [0 0 0] [0] [splitAt#1](x1, x2) = [1 0 1] x1 + [0 0 0] x2 + [0] [0 0 0] [1 0 0] [0] [0 0 0] [1 0 0] [1] [splitAt#2](x1, x2) = [0 0 0] x1 + [1 0 1] x2 + [1] [1 0 0] [0 0 0] [0] [1 0 0] [1] [splitAt#3](x1, x2) = [0 1 0] x1 + [0] [0 0 1] [1] [1 0 0] [0] [zipWithAnd#1](x1, x2) = [0 0 0] x1 + [0] [0 0 0] [0] [1 0 0] [1] [zipWithAnd#2](x1, x2, x3) = [0 0 0] x3 + [0] [0 0 0] [0] [1 0 0] [0] [zipWithOr#1](x1, x2) = [0 0 0] x1 + [0] [0 0 0] [0] [1 0 0] [1] [zipWithOr#2](x1, x2, x3) = [0 0 0] x3 + [0] [0 0 0] [0] [1 0 0] [0] [#neg](x1) = [1 0 0] x1 + [0] [0 0 1] [1] [1 0 0] [1] [#pred](x1) = [0 1 0] x1 + [1] [0 0 1] [1] [1 0 0] [0] [#succ](x1) = [0 1 0] x1 + [0] [0 0 1] [0] [0] [+^#](x1, x2) = [0] [0] [0] [#add^#](x1, x2) = [0] [0] [0] [and^#](x1, x2) = [0] [0] [0] [#and^#](x1, x2) = [0] [0] [1 0 0] [0] [append^#](x1, x2) = [0 0 0] x1 + [0] [0 0 0] [1] [1 0 0] [0] [append#1^#](x1, x2) = [0 0 0] x1 + [1] [0 0 0] [0] [0] [append#2^#](x1, x2) = [0] [0] [1 0 0] [1] [bitonicMerge^#](x1, x2) = [0 0 0] x1 + [0] [0 0 0] [1] [1 0 0] [1] [bitonicMerge#1^#](x1, x2, x3) = [0 0 0] x3 + [0] [0 0 0] [1] [1 0 0] [1] [bitonicMerge#2^#](x1, x2, x3) = [0 0 0] x3 + [0] [0 0 0] [1] [1 0 0] [1 0 0] [1] [bitonicMerge#3^#](x1, x2, x3) = [0 0 0] x1 + [0 0 0] x3 + [0] [0 0 0] [0 0 0] [1] [0] [div2^#](x1) = [0] [0] [0] [length^#](x1) = [0] [0] [0] [bitonicMerge#10^#](x1, x2, x3) = [0] [0] [0] [length#1^#](x1) = [0] [0] [0] [div2#1^#](x1) = [0] [0] [1 0 1] [1] [bitonicMerge#4^#](x1, x2) = [0 0 0] x1 + [0] [0 0 0] [1] [0] [splitAt^#](x1, x2) = [0] [0] [0] [splitAt#1^#](x1, x2) = [0] [0] [1 0 1] [1 0 0] [1] [bitonicMerge#5^#](x1, x2, x3) = [0 0 0] x1 + [0 0 0] x3 + [0] [0 0 0] [0 0 0] [1] [0] [bitonicMerge#6^#](x1) = [0] [0] [0] [zipWithOr^#](x1, x2) = [0] [0] [1 0 0] [1 0 0] [1] [bitonicMerge#7^#](x1, x2, x3) = [0 0 0] x1 + [0 0 0] x3 + [0] [0 0 0] [0 0 0] [1] [0] [bitonicMerge#8^#](x1) = [0] [0] [0] [zipWithAnd^#](x1, x2) = [0] [0] [0 0 1] [1] [bitonicMerge#9^#](x1, x2) = [0 0 0] x1 + [0] [0 0 0] [1] [0] [zipWithOr#1^#](x1, x2) = [0] [0] [0] [zipWithAnd#1^#](x1, x2) = [0] [0] [1 0 0] [1] [bitonicSort^#](x1, x2) = [0 0 0] x1 + [0] [0 0 0] [1] [1 0 0] [1] [bitonicSort#1^#](x1, x2, x3) = [0 0 0] x3 + [0] [0 0 0] [1] [0 0 1] [1] [bitonicSort#2^#](x1, x2) = [0 0 0] x1 + [0] [0 0 0] [1] [0] [split^#](x1) = [0] [0] [0] [split#1^#](x1) = [0] [0] [1 0 0] [1 0 0] [1] [bitonicSort#3^#](x1, x2, x3, x4) = [0 0 0] x3 + [0 0 0] x4 + [0] [0 0 0] [0 0 0] [1] [1 0 0] [1 0 0] [1] [bitonicSort#4^#](x1, x2, x3, x4) = [0 0 0] x3 + [0 0 0] x4 + [0] [0 0 0] [0 0 0] [1] [0] [div2#2^#](x1) = [0] [0] [0] [or^#](x1, x2) = [0] [0] [0] [#or^#](x1, x2) = [0] [0] [0] [split#2^#](x1, x2) = [0] [0] [0] [split#3^#](x1, x2, x3) = [0] [0] [0] [splitAt#2^#](x1, x2) = [0] [0] [0] [splitAt#3^#](x1, x2) = [0] [0] [0] [zipWithAnd#2^#](x1, x2, x3) = [0] [0] [0] [zipWithOr#2^#](x1, x2, x3) = [0] [0] [0] [#succ^#](x1) = [0] [0] [0] [#pred^#](x1) = [0] [0] [1 0 0] [0] [c_1](x1) = [0 0 0] x1 + [0] [0 0 0] [0] [1 0 0] [0] [c_2](x1) = [0 0 0] x1 + [0] [0 0 0] [0] [0] [c_3](x1) = [0] [0] [0] [c_4](x1) = [0] [0] [0] [c_5](x1) = [0] [0] [0] [c_10](x1) = [0] [0] [0] [c_13](x1) = [0] [0] [0] [c_15](x1) = [0] [0] [0] [c_17](x1) = [0] [0] [0] [c_18](x1) = [0] [0] [0] [c_26](x1) = [0] [0] [0] [c_27](x1) = [0] [0] This order satisfies following ordering constraints [+(@x, @y)] = [1 0 0] [1 0 0] [0] [1 1 0] @x + [1 1 0] @y + [0] [1 0 0] [1 0 1] [0] >= [1 0 0] [1 0 0] [0] [1 0 0] @x + [0 1 0] @y + [0] [1 0 0] [0 0 1] [0] = [#add(@x, @y)] [#add(#0(), @y)] = [1 0 0] [0] [0 1 0] @y + [0] [0 0 1] [0] >= [1 0 0] [0] [0 1 0] @y + [0] [0 0 1] [0] = [@y] [#add(#pos(#s(#0())), @y)] = [1 0 0] [0] [0 1 0] @y + [0] [0 0 1] [0] >= [1 0 0] [0] [0 1 0] @y + [0] [0 0 1] [0] = [#succ(@y)] [#add(#pos(#s(#s(@x))), @y)] = [1 0 0] [0] [0 1 0] @y + [0] [0 0 1] [0] >= [1 0 0] [0] [0 1 0] @y + [0] [0 0 1] [0] = [#succ(#add(#pos(#s(@x)), @y))] [#add(#neg(#s(#0())), @y)] = [1 0 0] [1] [0 1 0] @y + [1] [0 0 1] [1] >= [1 0 0] [1] [0 1 0] @y + [1] [0 0 1] [1] = [#pred(@y)] [#add(#neg(#s(#s(@x))), @y)] = [1 0 0] [1 0 0] [2] [1 0 0] @x + [0 1 0] @y + [2] [1 0 0] [0 0 1] [2] > [1 0 0] [1] [0 1 0] @y + [1] [0 0 1] [1] = [#pred(#add(#pos(#s(@x)), @y))] [append(@l, @ys)] = [1 0 0] [1 0 0] [0] [0 0 0] @l + [0 1 0] @ys + [0] [0 0 0] [0 0 1] [0] >= [1 0 0] [1 0 0] [0] [0 0 0] @l + [0 1 0] @ys + [0] [0 0 0] [0 0 1] [0] = [append#1(@l, @ys)] [append#1(::(@x, @xs), @ys)] = [1 0 0] [1 0 0] [1] [0 0 0] @xs + [0 1 0] @ys + [0] [0 0 0] [0 0 1] [0] >= [1 0 0] [1 0 0] [1] [0 0 0] @xs + [0 0 0] @ys + [0] [0 0 0] [0 0 0] [0] = [append#2(append(@xs, @ys), @x)] [append#1(nil(), @ys)] = [1 0 0] [0] [0 1 0] @ys + [0] [0 0 1] [0] >= [1 0 0] [0] [0 1 0] @ys + [0] [0 0 1] [0] = [@ys] [append#2(@l', @x)] = [1 0 0] [1] [0 0 0] @l' + [0] [0 0 0] [0] >= [1 0 0] [1] [0 0 0] @l' + [0] [0 0 0] [0] = [::(@x, @l')] [bitonicMerge(@l, @direction)] = [0 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 0] @l + [1] [1 1 1] [1 1 1] [1] >= [0 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 0] @l + [1] [1 1 1] [1 1 1] [1] = [bitonicMerge#1(@l, @direction, @l)] [bitonicMerge#1(::(@x, @xs), @direction, @l)] = [0 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 0] @l + [1] [1 1 1] [1 0 1] [1] >= [0 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 0] @l + [1] [1 1 1] [1 0 1] [1] = [bitonicMerge#2(@xs, @direction, @l)] [bitonicMerge#1(nil(), @direction, @l)] = [0 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 0] @l + [1] [1 1 1] [1 0 1] [1] >= [0] [0] [0] = [nil()] [bitonicMerge#2(::(@y, @ys), @direction, @l)] = [0 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 0] @l + [1] [1 1 1] [1 0 1] [1] >= [0 0 0] [1 0 0] [0] [1 1 1] @direction + [1 0 0] @l + [1] [1 1 1] [1 0 1] [1] = [bitonicMerge#3(div2(length(@l)), @direction, @l)] [bitonicMerge#2(nil(), @direction, @l)] = [0 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 0] @l + [1] [1 1 1] [1 0 1] [1] >= [1 0 0] [0] [0 1 0] @l + [0] [0 0 1] [0] = [@l] [bitonicMerge#10(#false(), @hi, @low)] = [1 0 0] [1 0 0] [0] [0 1 1] @hi + [0 1 1] @low + [1] [1 0 0] [1 0 0] [0] >= [0 0 0] [1 0 0] [0] [0 0 0] @hi + [0 1 1] @low + [1] [1 0 0] [1 0 0] [0] = [tuple#2(@low, @hi)] [bitonicMerge#10(#true(), @hi, @low)] = [1 0 0] [1 0 0] [0] [0 1 1] @hi + [0 1 1] @low + [1] [1 0 0] [1 0 0] [0] >= [1 0 0] [0 0 0] [0] [0 1 1] @hi + [0 0 0] @low + [1] [1 0 0] [1 0 0] [0] = [tuple#2(@hi, @low)] [div2(@n)] = [0] [1] [1] >= [0] [1] [1] = [div2#1(@n)] [bitonicMerge#3(@h, @direction, @l)] = [0 0 0] [1 0 0] [1 0 0] [0] [1 1 1] @direction + [1 0 0] @h + [1 0 0] @l + [1] [1 1 1] [1 0 0] [1 0 1] [1] >= [0 0 0] [1 0 0] [1 0 0] [0] [1 1 1] @direction + [1 0 0] @h + [1 0 0] @l + [1] [1 1 1] [1 0 0] [1 0 0] [1] = [bitonicMerge#4(splitAt(@h, @l), @direction)] [splitAt(@n, @l)] = [0 0 0] [1 0 0] [0] [0 0 0] @l + [1 0 1] @n + [0] [1 0 0] [0 0 0] [0] >= [0 0 0] [1 0 0] [0] [0 0 0] @l + [1 0 1] @n + [0] [1 0 0] [0 0 0] [0] = [splitAt#1(@n, @l)] [bitonicMerge#4(@s, @direction)] = [0 0 0] [1 0 1] [0] [1 1 1] @direction + [1 0 1] @s + [1] [1 1 1] [1 0 1] [1] >= [0 0 0] [1 0 1] [0] [1 1 1] @direction + [1 0 1] @s + [1] [1 1 1] [1 0 1] [1] = [bitonicMerge#5(bitonicMerge#6(@s), @direction, @s)] [bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2))] = [1 0 0] [1 0 0] [0] [0 0 0] @zipWithOr@1 + [0 0 0] @zipWithOr@2 + [0] [0 0 0] [0 0 0] [0] >= [1 0 0] [0] [0 0 0] @zipWithOr@1 + [0] [0 0 0] [0] = [zipWithOr(@zipWithOr@1, @zipWithOr@2)] [bitonicMerge#5(@hi, @direction, @s)] = [0 0 0] [1 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 1] @hi + [1 0 0] @s + [1] [1 1 1] [1 1 1] [1 0 0] [1] >= [0 0 0] [1 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 1] @hi + [1 0 0] @s + [1] [1 1 1] [1 1 1] [1 0 0] [1] = [bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi)] [bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4))] = [1 0 0] [0] [0 0 0] @zipWithAnd@3 + [0] [0 0 0] [0] >= [1 0 0] [0] [0 0 0] @zipWithAnd@3 + [0] [0 0 0] [0] = [zipWithAnd(@zipWithAnd@3, @zipWithAnd@4)] [bitonicMerge#7(@low, @direction, @hi)] = [0 0 0] [1 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 1] @hi + [1 1 1] @low + [1] [1 1 1] [1 1 1] [1 1 1] [1] >= [0 0 0] [1 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 1] @hi + [1 1 1] @low + [1] [1 1 1] [1 1 1] [1 1 1] [1] = [bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction)] [zipWithOr(@l1, @l2)] = [1 0 0] [0] [0 0 0] @l1 + [0] [0 0 0] [0] >= [1 0 0] [0] [0 0 0] @l1 + [0] [0 0 0] [0] = [zipWithOr#1(@l1, @l2)] [bitonicMerge#9(tuple#2(@hi, @low), @direction)] = [0 0 0] [1 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 1] @hi + [0 0 0] @low + [1] [1 1 1] [1 1 1] [0 0 0] [1] >= [0 0 0] [1 0 0] [1 0 0] [0] [1 1 1] @direction + [1 1 0] @hi + [0 0 0] @low + [1] [1 1 1] [1 1 1] [0 0 0] [1] = [append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction))] [zipWithAnd(@l1, @l2)] = [1 0 0] [0] [0 0 0] @l1 + [0] [0 0 0] [0] >= [1 0 0] [0] [0 0 0] @l1 + [0] [0 0 0] [0] = [zipWithAnd#1(@l1, @l2)] [split(@l)] = [1 0 0] [1] [0 0 0] @l + [1] [1 0 0] [0] > [1 0 0] [0] [0 0 0] @l + [1] [1 0 0] [0] = [split#1(@l)] [div2#1(#0())] = [0] [1] [1] >= [0] [0] [1] = [#0()] [div2#1(#s(@n))] = [0] [1] [1] >= [0] [1] [1] = [div2#2(@n)] [div2#2(#0())] = [0] [1] [1] >= [0] [0] [1] = [#0()] [div2#2(#s(@n))] = [0] [1] [1] >= [0] [1] [1] = [+(#pos(#s(#0())), div2(@n))] [split#1(::(@x1, @xs))] = [1 0 0] [1] [0 0 0] @xs + [1] [1 0 0] [1] > [1 0 0] [0] [0 0 0] @xs + [1] [1 0 0] [1] = [split#2(@xs, @x1)] [split#1(nil())] = [0] [1] [0] >= [0] [1] [0] = [tuple#2(nil(), nil())] [split#2(::(@x2, @xs'), @x1)] = [1 0 0] [1] [0 0 0] @xs' + [1] [1 0 0] [2] >= [1 0 0] [1] [0 0 0] @xs' + [1] [1 0 0] [2] = [split#3(split(@xs'), @x1, @x2)] [split#2(nil(), @x1)] = [0] [1] [1] >= [0] [1] [0] = [tuple#2(nil(), nil())] [split#3(tuple#2(@l1, @l2), @x1, @x2)] = [1 0 0] [1 0 0] [1] [0 1 1] @l1 + [0 0 0] @l2 + [1] [1 1 1] [1 0 0] [2] >= [1 0 0] [0 0 0] [1] [0 0 0] @l1 + [0 0 0] @l2 + [1] [1 0 0] [1 0 0] [2] = [tuple#2(::(@x1, @l1), ::(@x2, @l2))] [splitAt#1(#0(), @l)] = [0 0 0] [0] [0 0 0] @l + [1] [1 0 0] [0] >= [0 0 0] [0] [0 0 0] @l + [1] [1 0 0] [0] = [tuple#2(nil(), @l)] [splitAt#1(#s(@n'), @l)] = [0 0 0] [1 0 0] [1] [0 0 0] @l + [1 0 1] @n' + [1] [1 0 0] [0 0 0] [0] >= [0 0 0] [1 0 0] [1] [0 0 0] @l + [1 0 1] @n' + [1] [1 0 0] [0 0 0] [0] = [splitAt#2(@l, @n')] [splitAt#2(::(@x, @xs), @n')] = [1 0 0] [0 0 0] [1] [1 0 1] @n' + [0 0 0] @xs + [1] [0 0 0] [1 0 0] [1] >= [1 0 0] [0 0 0] [1] [1 0 1] @n' + [0 0 0] @xs + [0] [0 0 0] [1 0 0] [1] = [splitAt#3(splitAt(@n', @xs), @x)] [splitAt#2(nil(), @n')] = [1 0 0] [1] [1 0 1] @n' + [1] [0 0 0] [0] > [0] [1] [0] = [tuple#2(nil(), nil())] [splitAt#3(tuple#2(@l1, @l2), @x)] = [1 0 0] [0 0 0] [1] [0 1 1] @l1 + [0 0 0] @l2 + [1] [1 0 0] [1 0 0] [1] >= [1 0 0] [0 0 0] [1] [0 0 0] @l1 + [0 0 0] @l2 + [1] [1 0 0] [1 0 0] [1] = [tuple#2(::(@x, @l1), @l2)] [zipWithAnd#1(::(@x, @xs), @l2)] = [1 0 0] [1] [0 0 0] @xs + [0] [0 0 0] [0] >= [1 0 0] [1] [0 0 0] @xs + [0] [0 0 0] [0] = [zipWithAnd#2(@l2, @x, @xs)] [zipWithAnd#1(nil(), @l2)] = [0] [0] [0] >= [0] [0] [0] = [nil()] [zipWithAnd#2(::(@y, @ys), @x, @xs)] = [1 0 0] [1] [0 0 0] @xs + [0] [0 0 0] [0] >= [1 0 0] [1] [0 0 0] @xs + [0] [0 0 0] [0] = [::(and(@x, @y), zipWithAnd(@xs, @ys))] [zipWithAnd#2(nil(), @x, @xs)] = [1 0 0] [1] [0 0 0] @xs + [0] [0 0 0] [0] > [0] [0] [0] = [nil()] [zipWithOr#1(::(@x, @xs), @l2)] = [1 0 0] [1] [0 0 0] @xs + [0] [0 0 0] [0] >= [1 0 0] [1] [0 0 0] @xs + [0] [0 0 0] [0] = [zipWithOr#2(@l2, @x, @xs)] [zipWithOr#1(nil(), @l2)] = [0] [0] [0] >= [0] [0] [0] = [nil()] [zipWithOr#2(::(@y, @ys), @x, @xs)] = [1 0 0] [1] [0 0 0] @xs + [0] [0 0 0] [0] >= [1 0 0] [1] [0 0 0] @xs + [0] [0 0 0] [0] = [::(or(@x, @y), zipWithOr(@xs, @ys))] [zipWithOr#2(nil(), @x, @xs)] = [1 0 0] [1] [0 0 0] @xs + [0] [0 0 0] [0] > [0] [0] [0] = [nil()] [#pred(#0())] = [1] [1] [2] >= [1] [1] [2] = [#neg(#s(#0()))] [#pred(#pos(#s(#0())))] = [1] [1] [2] > [0] [0] [1] = [#0()] [#pred(#pos(#s(#s(@x))))] = [0 0 0] [1] [0 0 0] @x + [1] [0 0 1] [1] > [0 0 0] [0] [0 0 0] @x + [0] [0 0 1] [0] = [#pos(#s(@x))] [#pred(#neg(#s(@x)))] = [1 0 0] [2] [1 0 0] @x + [2] [0 0 1] [2] >= [1 0 0] [2] [1 0 0] @x + [2] [0 0 1] [1] = [#neg(#s(#s(@x)))] [#succ(#0())] = [0] [0] [1] >= [0] [0] [1] = [#pos(#s(#0()))] [#succ(#pos(#s(@x)))] = [0 0 0] [0] [0 0 0] @x + [0] [0 0 1] [0] >= [0 0 0] [0] [0 0 0] @x + [0] [0 0 1] [0] = [#pos(#s(#s(@x)))] [#succ(#neg(#s(#0())))] = [1] [1] [2] > [0] [0] [1] = [#0()] [#succ(#neg(#s(#s(@x))))] = [1 0 0] [2] [1 0 0] @x + [2] [0 0 1] [1] > [1 0 0] [1] [1 0 0] @x + [1] [0 0 1] [1] = [#neg(#s(@x))] [append^#(@l, @ys)] = [1 0 0] [0] [0 0 0] @l + [0] [0 0 0] [1] >= [1 0 0] [0] [0 0 0] @l + [0] [0 0 0] [0] = [c_1(append#1^#(@l, @ys))] [append#1^#(::(@x, @xs), @ys)] = [1 0 0] [1] [0 0 0] @xs + [1] [0 0 0] [0] > [1 0 0] [0] [0 0 0] @xs + [0] [0 0 0] [0] = [c_2(append^#(@xs, @ys))] [bitonicMerge^#(@l, @direction)] = [1 0 0] [1] [0 0 0] @l + [0] [0 0 0] [1] >= [1 0 0] [1] [0 0 0] @l + [0] [0 0 0] [1] = [bitonicMerge#1^#(@l, @direction, @l)] [bitonicMerge#1^#(::(@x, @xs), @direction, @l)] = [1 0 0] [1] [0 0 0] @l + [0] [0 0 0] [1] >= [1 0 0] [1] [0 0 0] @l + [0] [0 0 0] [1] = [bitonicMerge#2^#(@xs, @direction, @l)] [bitonicMerge#2^#(::(@y, @ys), @direction, @l)] = [1 0 0] [1] [0 0 0] @l + [0] [0 0 0] [1] >= [1 0 0] [1] [0 0 0] @l + [0] [0 0 0] [1] = [bitonicMerge#3^#(div2(length(@l)), @direction, @l)] [bitonicMerge#3^#(@h, @direction, @l)] = [1 0 0] [1 0 0] [1] [0 0 0] @h + [0 0 0] @l + [0] [0 0 0] [0 0 0] [1] >= [1 0 0] [1 0 0] [1] [0 0 0] @h + [0 0 0] @l + [0] [0 0 0] [0 0 0] [1] = [bitonicMerge#4^#(splitAt(@h, @l), @direction)] [bitonicMerge#4^#(@s, @direction)] = [1 0 1] [1] [0 0 0] @s + [0] [0 0 0] [1] >= [1 0 1] [1] [0 0 0] @s + [0] [0 0 0] [1] = [bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s)] [bitonicMerge#5^#(@hi, @direction, @s)] = [1 0 1] [1 0 0] [1] [0 0 0] @hi + [0 0 0] @s + [0] [0 0 0] [0 0 0] [1] >= [1 0 0] [1 0 0] [1] [0 0 0] @hi + [0 0 0] @s + [0] [0 0 0] [0 0 0] [1] = [bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi)] [bitonicMerge#7^#(@low, @direction, @hi)] = [1 0 0] [1 0 0] [1] [0 0 0] @hi + [0 0 0] @low + [0] [0 0 0] [0 0 0] [1] >= [1 0 0] [1 0 0] [1] [0 0 0] @hi + [0 0 0] @low + [0] [0 0 0] [0 0 0] [1] = [bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction)] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1 0 0] [1 0 0] [1] [0 0 0] @hi + [0 0 0] @low + [0] [0 0 0] [0 0 0] [1] > [1 0 0] [0] [0 0 0] @low + [0] [0 0 0] [1] = [append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction))] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1 0 0] [1 0 0] [1] [0 0 0] @hi + [0 0 0] @low + [0] [0 0 0] [0 0 0] [1] >= [1 0 0] [1] [0 0 0] @hi + [0] [0 0 0] [1] = [bitonicMerge^#(@hi, @direction)] [bitonicMerge#9^#(tuple#2(@hi, @low), @direction)] = [1 0 0] [1 0 0] [1] [0 0 0] @hi + [0 0 0] @low + [0] [0 0 0] [0 0 0] [1] >= [1 0 0] [1] [0 0 0] @low + [0] [0 0 0] [1] = [bitonicMerge^#(@low, @direction)] [bitonicSort^#(@l, @dir)] = [1 0 0] [1] [0 0 0] @l + [0] [0 0 0] [1] >= [1 0 0] [1] [0 0 0] @l + [0] [0 0 0] [1] = [bitonicSort#1^#(@l, @dir, @l)] [bitonicSort#1^#(::(@x, @xs), @dir, @l)] = [1 0 0] [1] [0 0 0] @l + [0] [0 0 0] [1] >= [1 0 0] [1] [0 0 0] @l + [0] [0 0 0] [1] = [bitonicSort#2^#(split(@l), @dir)] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [1 0 0] [1 0 0] [1] [0 0 0] @l1 + [0 0 0] @l2 + [0] [0 0 0] [0 0 0] [1] >= [1 0 0] [1] [0 0 0] @l1 + [0] [0 0 0] [1] = [bitonicSort^#(@l1, #true())] [bitonicSort#2^#(tuple#2(@l1, @l2), @dir)] = [1 0 0] [1 0 0] [1] [0 0 0] @l1 + [0 0 0] @l2 + [0] [0 0 0] [0 0 0] [1] >= [1 0 0] [1 0 0] [1] [0 0 0] @l1 + [0 0 0] @l2 + [0] [0 0 0] [0 0 0] [1] = [bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2)] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [1 0 0] [1 0 0] [1] [0 0 0] @l1 + [0 0 0] @l2 + [0] [0 0 0] [0 0 0] [1] >= [1 0 0] [1] [0 0 0] @l2 + [0] [0 0 0] [1] = [bitonicSort^#(@l2, #false())] [bitonicSort#3^#(@s1, @dir, @l1, @l2)] = [1 0 0] [1 0 0] [1] [0 0 0] @l1 + [0 0 0] @l2 + [0] [0 0 0] [0 0 0] [1] >= [1 0 0] [1 0 0] [1] [0 0 0] @l1 + [0 0 0] @l2 + [0] [0 0 0] [0 0 0] [1] = [bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2)] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [1 0 0] [1 0 0] [1] [0 0 0] @l1 + [0 0 0] @l2 + [0] [0 0 0] [0 0 0] [1] > [1 0 0] [0] [0 0 0] @l1 + [0] [0 0 0] [1] = [append^#(@l1, @l2)] [bitonicSort#4^#(@s2, @dir, @l1, @l2)] = [1 0 0] [1 0 0] [1] [0 0 0] @l1 + [0 0 0] @l2 + [0] [0 0 0] [0 0 0] [1] >= [1 0 0] [1 0 0] [1] [0 0 0] @l1 + [0 0 0] @l2 + [0] [0 0 0] [0 0 0] [1] = [bitonicMerge^#(append(@l1, @l2), @dir)] Consider the set of all dependency pairs DPs: { 1: append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , 2: append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , 3: bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , 4: bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , 5: bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , 6: bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , 7: bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , 8: bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , 9: bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , 10: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , 11: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , 12: bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , 13: bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , 14: bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , 15: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , 16: bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , 17: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , 18: bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , 19: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , 20: bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) } Processor 'matrix interpretation of dimension 3' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {2,10,19}. These cover all (indirect) predecessors of dependency pairs {1,2,10,19}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) } Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { append^#(@l, @ys) -> c_1(append#1^#(@l, @ys)) , append#1^#(::(@x, @xs), @ys) -> c_2(append^#(@xs, @ys)) , bitonicMerge^#(@l, @direction) -> bitonicMerge#1^#(@l, @direction, @l) , bitonicMerge#1^#(::(@x, @xs), @direction, @l) -> bitonicMerge#2^#(@xs, @direction, @l) , bitonicMerge#2^#(::(@y, @ys), @direction, @l) -> bitonicMerge#3^#(div2(length(@l)), @direction, @l) , bitonicMerge#3^#(@h, @direction, @l) -> bitonicMerge#4^#(splitAt(@h, @l), @direction) , bitonicMerge#4^#(@s, @direction) -> bitonicMerge#5^#(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#5^#(@hi, @direction, @s) -> bitonicMerge#7^#(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#7^#(@low, @direction, @hi) -> bitonicMerge#9^#(bitonicMerge#10(@direction, @hi, @low), @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> append^#(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@hi, @direction) , bitonicMerge#9^#(tuple#2(@hi, @low), @direction) -> bitonicMerge^#(@low, @direction) , bitonicSort^#(@l, @dir) -> bitonicSort#1^#(@l, @dir, @l) , bitonicSort#1^#(::(@x, @xs), @dir, @l) -> bitonicSort#2^#(split(@l), @dir) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort^#(@l1, #true()) , bitonicSort#2^#(tuple#2(@l1, @l2), @dir) -> bitonicSort#3^#(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort^#(@l2, #false()) , bitonicSort#3^#(@s1, @dir, @l1, @l2) -> bitonicSort#4^#(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> append^#(@l1, @l2) , bitonicSort#4^#(@s2, @dir, @l1, @l2) -> bitonicMerge^#(append(@l1, @l2), @dir) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { +(@x, @y) -> #add(@x, @y) , #add(#0(), @y) -> @y , #add(#pos(#s(#0())), @y) -> #succ(@y) , #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) , #add(#neg(#s(#0())), @y) -> #pred(@y) , #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) , and(@x, @y) -> #and(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() , append(@l, @ys) -> append#1(@l, @ys) , append#1(::(@x, @xs), @ys) -> append#2(append(@xs, @ys), @x) , append#1(nil(), @ys) -> @ys , append#2(@l', @x) -> ::(@x, @l') , bitonicMerge(@l, @direction) -> bitonicMerge#1(@l, @direction, @l) , bitonicMerge#1(::(@x, @xs), @direction, @l) -> bitonicMerge#2(@xs, @direction, @l) , bitonicMerge#1(nil(), @direction, @l) -> nil() , bitonicMerge#2(::(@y, @ys), @direction, @l) -> bitonicMerge#3(div2(length(@l)), @direction, @l) , bitonicMerge#2(nil(), @direction, @l) -> @l , bitonicMerge#10(#false(), @hi, @low) -> tuple#2(@low, @hi) , bitonicMerge#10(#true(), @hi, @low) -> tuple#2(@hi, @low) , length(@l) -> length#1(@l) , div2(@n) -> div2#1(@n) , bitonicMerge#3(@h, @direction, @l) -> bitonicMerge#4(splitAt(@h, @l), @direction) , splitAt(@n, @l) -> splitAt#1(@n, @l) , bitonicMerge#4(@s, @direction) -> bitonicMerge#5(bitonicMerge#6(@s), @direction, @s) , bitonicMerge#6(tuple#2(@zipWithOr@1, @zipWithOr@2)) -> zipWithOr(@zipWithOr@1, @zipWithOr@2) , bitonicMerge#5(@hi, @direction, @s) -> bitonicMerge#7(bitonicMerge#8(@s), @direction, @hi) , bitonicMerge#8(tuple#2(@zipWithAnd@3, @zipWithAnd@4)) -> zipWithAnd(@zipWithAnd@3, @zipWithAnd@4) , bitonicMerge#7(@low, @direction, @hi) -> bitonicMerge#9(bitonicMerge#10(@direction, @hi, @low), @direction) , zipWithOr(@l1, @l2) -> zipWithOr#1(@l1, @l2) , bitonicMerge#9(tuple#2(@hi, @low), @direction) -> append(bitonicMerge(@low, @direction), bitonicMerge(@hi, @direction)) , zipWithAnd(@l1, @l2) -> zipWithAnd#1(@l1, @l2) , bitonicSort(@l, @dir) -> bitonicSort#1(@l, @dir, @l) , bitonicSort#1(::(@x, @xs), @dir, @l) -> bitonicSort#2(split(@l), @dir) , bitonicSort#1(nil(), @dir, @l) -> nil() , split(@l) -> split#1(@l) , bitonicSort#2(tuple#2(@l1, @l2), @dir) -> bitonicSort#3(bitonicSort(@l1, #true()), @dir, @l1, @l2) , bitonicSort#3(@s1, @dir, @l1, @l2) -> bitonicSort#4(bitonicSort(@l2, #false()), @dir, @l1, @l2) , bitonicSort#4(@s2, @dir, @l1, @l2) -> bitonicMerge(append(@l1, @l2), @dir) , div2#1(#0()) -> #0() , div2#1(#s(@n)) -> div2#2(@n) , div2#2(#0()) -> #0() , div2#2(#s(@n)) -> +(#pos(#s(#0())), div2(@n)) , length#1(::(@x, @xs)) -> +(#pos(#s(#0())), length(@xs)) , length#1(nil()) -> #0() , or(@x, @y) -> #or(@x, @y) , #or(#false(), #false()) -> #false() , #or(#false(), #true()) -> #true() , #or(#true(), #false()) -> #true() , #or(#true(), #true()) -> #true() , split#1(::(@x1, @xs)) -> split#2(@xs, @x1) , split#1(nil()) -> tuple#2(nil(), nil()) , split#2(::(@x2, @xs'), @x1) -> split#3(split(@xs'), @x1, @x2) , split#2(nil(), @x1) -> tuple#2(nil(), nil()) , split#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) , splitAt#1(#0(), @l) -> tuple#2(nil(), @l) , splitAt#1(#s(@n'), @l) -> splitAt#2(@l, @n') , splitAt#2(::(@x, @xs), @n') -> splitAt#3(splitAt(@n', @xs), @x) , splitAt#2(nil(), @n') -> tuple#2(nil(), nil()) , splitAt#3(tuple#2(@l1, @l2), @x) -> tuple#2(::(@x, @l1), @l2) , zipWithAnd#1(::(@x, @xs), @l2) -> zipWithAnd#2(@l2, @x, @xs) , zipWithAnd#1(nil(), @l2) -> nil() , zipWithAnd#2(::(@y, @ys), @x, @xs) -> ::(and(@x, @y), zipWithAnd(@xs, @ys)) , zipWithAnd#2(nil(), @x, @xs) -> nil() , zipWithOr#1(::(@x, @xs), @l2) -> zipWithOr#2(@l2, @x, @xs) , zipWithOr#1(nil(), @l2) -> nil() , zipWithOr#2(::(@y, @ys), @x, @xs) -> ::(or(@x, @y), zipWithOr(@xs, @ys)) , zipWithOr#2(nil(), @x, @xs) -> nil() , #pred(#0()) -> #neg(#s(#0())) , #pred(#pos(#s(#0()))) -> #0() , #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) , #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) , #succ(#0()) -> #pos(#s(#0())) , #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) , #succ(#neg(#s(#0()))) -> #0() , #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded Wall-time: 11.028741s CPU-time: 78.422s Wall-time: 28.222377s CPU-time: 199.774s Wall-time: 158.483246s CPU-time: 1150.947s Hurray, we answered YES(O(1),O(n^4))